ENSAMBLE DEL BRAZO GPIO - T.I. KIT DE APRENDIZAJE DEL SISTEMA DE ROBÓTICA - LABORATORIO 6: 3 Pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Hola, En un Instructable anterior sobre el aprendizaje del ensamblaje ARM usando el TI-RSLK de Texas Instruments (usa el microcontrolador MSP432), también conocido como Lab 3 si está haciendo el T. I. Por supuesto, repasamos algunas instrucciones muy básicas, como escribir en un registro y bucle condicional. Pasamos por la ejecución utilizando el IDE de Eclipse.

Los pequeños programas que ejecutamos no hicieron nada para interactuar con el mundo exterior.

Un poco aburrido.

Intentemos cambiar eso un poco hoy aprendiendo un poco sobre los puertos de entrada / salida, específicamente, los pines GPIO digitales.

Da la casualidad de que este MSP432 viene en una placa de desarrollo que ya tiene dos interruptores de botón, un LED RGB y un LED rojo, todos los cuales están vinculados a algunos puertos GPIO.

Esto significa que a medida que aprendemos a configurar y manipular estos pines mediante el ensamblaje, podemos ver visualmente esos efectos.

Mucho más interesante que simplemente recorrer el depurador.

(Todavía vamos a dar un paso, esta será nuestra función de 'retraso'):-D

Paso 1: Intentemos escribir o leer desde RAM

Antes de saltar a acceder y controlar el GPIO, deberíamos dar un pequeño paso.

Comencemos simplemente leyendo y escribiendo en una dirección de memoria estándar. Sabemos por el Instructable anterior (vea las imágenes allí) que la RAM comienza en 0x2000 0000, así que usemos esa dirección.

Vamos a mover datos entre un registro central (R0) y 0x2000 0000.

Comenzamos con una estructura de archivo básica o el contenido de un programa ensamblador. Consulte este Instructable para crear un proyecto de ensamblaje utilizando Code Composer Studio (CCS) de TI y algunos proyectos de muestra.

.pulgar

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

Quiero agregar algo nuevo a la sección superior, donde hay algunas declaraciones (directivas). Se aclarará más tarde.

ACONST.set 0x20000000; usaremos esto más abajo (es una constante)

; obviamente, '0x' denota que lo que sigue es un valor hexadecimal.

Entonces, el contenido de nuestro archivo inicial ahora se ve así:

.pulgar

.text.align 2 ACONST.set 0x20000000; usaremos esto más abajo (es una constante); obviamente, '0x' denota que lo que sigue es un valor hexadecimal..global main.thumbfunc main main:.asmfunc; --------------------------------------- ------------------------------------------; (nuestro código irá aquí); ------------------------------------------ ---------------------------------------.endasmfunc.end

Ahora que tenemos lo anterior, agreguemos código entre las líneas discontinuas.

Comenzamos escribiendo en una ubicación RAM. Primero estableceremos el patrón de datos, un valor, que escribiremos en la RAM. Usamos un registro central para establecer ese valor o datos.

Nota: recuerde que en el código, cualquier línea que tenga un punto y coma (';') significa que todo es un comentario después de ese punto y coma.

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

; ESCRIBIENDO;------------------------------------------------ ----------------------------------------------- MOV R0, # 0x55; El registro central R0 contendrá los datos que queremos escribir en la ubicación de la RAM.; obviamente, '0x' denota que lo que sigue es un valor hexadecimal.

A continuación, echemos un vistazo a las declaraciones que NO funcionan.

; MOV MOV no se puede utilizar para escribir datos en una ubicación de RAM.

; MOV es solo para datos inmediatos en el registro; o de un registro a otro; es decir, MOV R1, R0.; STR debe usar STR.; STR R0, = ACONST; Término incorrecto en la expresión (el '='); STR R0, 0x20000000; Modo de direccionamiento ilegal para instrucciones de tienda; STR R0, ACONST; Modo de direccionamiento ilegal para instrucciones de tienda

Sin explicar demasiado, intentamos usar ese 'ACONST' anterior. Esencialmente, es un sustituto o constante en lugar de usar un valor literal como 0x20000000.

No pudimos escribir para escribir en la ubicación de la RAM usando lo anterior. Intentemos algo más.

; parece que debemos usar otro registro que contenga la ubicación de la RAM en

; para almacenar en esa ubicación RAM MOV R1, # 0x20000000; establezca la ubicación de la RAM (no su contenido, sino la ubicación) en R1.; obviamente, '0x' denota que lo que sigue es un valor hexadecimal. STR R0, [R1]; escriba lo que hay en R0 (0x55) en la RAM (0x20000000) usando R1.; usamos otro registro (R1) que tiene una dirección de ubicación de RAM; para escribir en esa ubicación de RAM.

Otra forma de hacer lo anterior, pero usando 'ACONST' en lugar del valor de la dirección literal:

; hagamos lo anterior de nuevo, pero usemos un símbolo en lugar de un valor de ubicación de RAM literal.

; queremos utilizar 'ACONST' como sustituto de 0x20000000.; todavía tenemos que hacer el '#' para significar un valor inmediato,; así que (ver arriba), tuvimos que usar la directiva '.set'.; para probar esto, cambiemos el patrón de datos en R0. MOV R0, # 0xAA; ok, estamos listos para escribir en la RAM usando el símbolo en lugar del valor de la dirección literal MOV R1, #ACONST STR R0, [R1]

El video entra en más detalles, además de leer paso a paso desde la ubicación de la memoria.

También puede ver el archivo.asm fuente adjunto.

Paso 2: Información básica del puerto

Ahora que tenemos una buena idea de cómo escribir / leer desde una ubicación RAM, esto nos ayudará a comprender mejor cómo controlar y usar el pin GPIO

Entonces, ¿cómo interactuamos con los pines GPIO? De nuestra mirada anterior a este microcontrolador y sus instrucciones ARM, sabemos cómo manejar sus registros internos y sabemos cómo interactuar con las direcciones de memoria (RAM). ¿Pero los pines GPIO?

Sucede que esos pines están mapeados en memoria, por lo que podemos tratarlos de la misma manera que las direcciones de memoria.

Esto significa que necesitamos saber cuáles son esas direcciones.

A continuación se muestran las direcciones de inicio de los puertos. Por cierto, para el MSP432, un "puerto" es una colección de pines, y no solo un pin. Si está familiarizado con la Raspberry Pi, creo que es diferente a la situación aquí.

Los círculos azules en la imagen de arriba muestran la escritura en la placa para los dos interruptores y LED. Las líneas azules apuntan a los LED reales. No tendremos que tocar los puentes del encabezado.

Hice los puertos que nos interesan en negrita a continuación.

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

Aún no hemos terminado. Necesitamos más información.

Para controlar un puerto, necesitamos varias direcciones. Por eso, en la lista anterior, vemos "direcciones pares" o "direcciones impares".

Bloques de direcciones de registro de E / S

Necesitaremos otras direcciones, como:

• Dirección de registro de entrada del puerto 1 = 0x40004C00
• Dirección de registro de salida del puerto 1 = 0x40004C02
• Dirección del registro de dirección del puerto 1 = 0x40004C04
• Puerto 1 Seleccione 0 Dirección de registro = 0x40004C0A
• Puerto 1 Seleccione 1 Dirección de registro = 0x40004C0C

Y es posible que necesitemos a otros.

Bien, ahora conocemos el rango de direcciones de registro GPIO para controlar un solo LED rojo.

Una nota muy importante: cada puerto de E / S en la placa MSP432 LaunchPad es una colección de varios (generalmente 8) pines o líneas, y cada uno puede configurarse individualmente como entrada o salida.

Esto significa, por ejemplo, que si está configurando valores para la "Dirección de registro de dirección del puerto 1", debe preocuparse por qué bit (o bits) está configurando o cambiando en esa dirección. Más sobre esto más adelante.

Secuencia de programación del puerto GPIO

La última pieza que necesitamos es un proceso o algoritmo a utilizar para controlar el LED.

Inicialización única:

• Configure P1.0 (P1SEL1REG: Registro P1SEL0REG) <--- 0x00, 0x00 para la funcionalidad GPIO normal.
• Establezca el bit 1 del registro de dirección de P1DIRREG como salida o HIGH.

Círculo:

Escriba HIGH en el bit 0 del registro P1OUTREG para encender el LED rojo

• Llamar a una función de retraso
• Escriba LOW en el bit 0 del registro P1OUTREG para apagar el LED rojo
• Llamar a una función de retraso
• Repetir bucle

Qué función de entrada / salida (configurar SEL0 y SEL1)

Muchos de los pines del LaunchPad tienen múltiples usos. Por ejemplo, el mismo pin podría ser GPIO digital estándar, o también se puede usar en comunicaciones seriales UART o I2C.

Para utilizar cualquier función específica para ese pin, debe seleccionar esa función. Necesitas configurar la función del pin.

Hay una imagen de arriba para este paso que intenta explicar este concepto en forma visual.

Las direcciones SEL0 y SEL1 forman una combinación de pares que actúa como una especie de selección de función / característica.

Para nuestros propósitos, queremos GPIO digital estándar para el bit 0. Eso significa que necesitamos el bit 0 para que SEL0 y SEL1 sean BAJOS.

Secuencia de programación de puertos (nuevamente)

1. Escriba 0x00 en el registro P1 SEL 0 (dirección 0x40004C0A). Esto establece un BAJO para el bit 0

2. Escriba 0x00 en el registro P1 SEL 1 (dirección 0x40004C0C). Esto establece un valor BAJO para el bit 0, valor para GPIO.

3. Escriba 0x01 en el registro DIR P1 (dirección 0x40004C04). Esto establece un ALTO para el bit 0, lo que significa SALIDA.

4. Encienda el LED escribiendo un 0x01 en el registro de SALIDA P1 (dirección 0x40004C02)

5. Realice algún tipo de retraso (o simplemente un solo paso durante la depuración)

6. Apague el LED escribiendo un 0x00 en el registro de SALIDA P1 (dirección 0x40004C02)

7. Realice algún tipo de retraso (o simplemente un solo paso durante la depuración)

8. Repita los pasos 4 a 7.

El video asociado para este paso nos lleva a través de todo el proceso en una demostración en vivo, a medida que avanzamos y hablamos de cada instrucción de ensamblaje, y mostramos la acción del LED. Disculpe la duración del video.

Paso 3: ¿Detectó el único defecto en el video?

En el video que recorre todo el proceso de programación e iluminación del LED, había un paso adicional en el bucle principal, que podría haberse movido hasta la inicialización única.

Gracias por tomarse el tiempo de revisar este Instructable.

El siguiente amplía lo que comenzamos aquí.