LibroDePracticas PDF

ANTONIO JOS VILLENA GODOY
RAFAEL ASENJO PLAZA

FRANCISCO J. CORBERA PEA
PRCTICAS DE ENSAMBLADOR
BASADAS EN
RASPBERRY PI
Departamento de Arquitectura de Computadores
UNIVERSIDAD DE MLAGA / MANUALES

ii
Aviso
Este material ha sido preparado por:

Antonio Jos Villena Godoy
Rafael Asenjo Plaza
Francisco J. Corbera Pea
Dept. de Arquitectura de Computadores. Universidad de Mlaga.
c Esta obra est bajo una Licencia Creative Commons Atribucin-NoComercial-

SinDerivar 4.0 Internacional.
b Debe dar crdito en la obra en la forma especificada por el autor o

licenciante.
e El licenciante permite copiar, distribuir y comunicar publicamente la

obra. A cambio, esta obra no puede ser utilizada con fines comerciales a
menos que se obtenga el permiso expreso del licenciante.
d El licenciante permite copiar, distribuir, transmitir y comunicar pbli-

camente solamente copias inalteradas de la obra no obras derivadas basadas
en ella.
Si desea enviar sugerencias, comentarios o propuestas de mejora sobre el con-

tenido de este material, envie un correo electrnico a la direccin asenjo@uma.
es.
iv
Acrnimos
AAPCS ARM Architecture Procedure Call Standard
ARM Advanced RISC Machines
CPSR Current Program Status Register
CPU Central Processing Unit
CHI system timer Counter HIgher
CLO system timer Counter LOwer
CS system timer Control/Status
E/S Entrada/Salida
ETSII Escuela Tcnica Superior de Ingeniera Informtica
FIQ Fast Interrupt reQuest
GNU GNU is Not Unix
GCC GNU C Compiler
GDB GNU DeBugger
GPAFEN GPIO Pin Async. Falling Edge Detect
GPAREN GPIO Pin Async. Rising Edge Detect
GPEDS GPIO Pin Event Detect Status
GPFEN GPIO Pin Falling Edge Detect Enable
GPHEN GPIO Pin High Detect Enable
GPIO General-Purpose Input/Output

GPL General Public License
GPLEN GPIO Pin Low Detect Enable
GPLEV GPIO Pin LEVel
GPPUD GPIO Pin High Detect Enable
GPPUDCLK GPIO Pin High Detect Enable CLocK
GPREN GPIO Pin Rising Edge Detect Enable
GPU Graphics Processing Unit
IRQ Interrupt ReQuest
LED Light Emitting Diode
LR Link Register
PFC Proyecto Fin de Carrera
PC Personal Computer
RAM Random-Access Memory
RISC Reduced Instruction Set Computer
ROM Read-Only Memory
RTI Rutina de Tratamiento de Interrupcin
SoC System on a Chip
SP Stack Pointer
SPSR Saved Program Status Register
UMA Universidad de Mlaga
VFP Vector Floating-Point
abt ABorT mode
mon secure MONitor mode
svc Supervisor mode (antiguamente SuperVisor Calls)
und UNDefined mode
ndice
Prlogo xv
1 Introduccin al ensamblador 1
1.1 Lectura previa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Caractersticas generales de la arquitectura ARM . . . . . . . 2
1.1.2 El lenguaje ensamblador . . . . . . . . . . . . . . . . . . . . . 5
1.1.3 El entorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.1.4 Configuracin del entorno para realizar las prcticas en casa . 7
1.1.5 Aspecto de un programa en ensamblador . . . . . . . . . . . . 9
1.1.6 Ensamblar y linkar un programa . . . . . . . . . . . . . . . . 14
1.2 Enunciados de la prctica . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.1 Cmo empezar . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.2 Enteros y naturales . . . . . . . . . . . . . . . . . . . . . . . . 20
1.2.3 Instrucciones lgicas . . . . . . . . . . . . . . . . . . . . . . . 23
1.2.4 Rotaciones y desplazamientos . . . . . . . . . . . . . . . . . . 25
1.2.5 Instrucciones de multiplicacin . . . . . . . . . . . . . . . . . 28
2 Tipos de datos y sentencias de alto nivel 31

2.1 Lectura previa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.1.1 Modos de direccionamiento del ARM . . . . . . . . . . . . . . 31
2.1.2 Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.1.3 Instrucciones de salto . . . . . . . . . . . . . . . . . . . . . . . 38
2.1.4 Estructuras de control de alto nivel . . . . . . . . . . . . . . . 42
2.1.5 Compilacin a ensamblador . . . . . . . . . . . . . . . . . . . 43
2.1.6 Ejercicios propuestos. . . . . . . . . . . . . . . . . . . . . . . . 46
2.2 Enunciados de la prctica . . . . . . . . . . . . . . . . . . . . . . . . 48
2.2.1 Suma de elementos de un vector . . . . . . . . . . . . . . . . . 48
3 Subrutinas y paso de parmetros 55

3.1 Lectura previa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.1.1 La pila y las instrucciones ldm y stm . . . . . . . . . . . . . . 56
vii
3.1.2 Convencin AAPCS . . . . . . . . . . . . . . . . . . . . . . . 58
3.2 Ejemplos de aplicacin . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.2.1 Funciones en ensamblador llamadas desde C . . . . . . . . . . 60
3.2.2 Funciones en ensamblador llamadas desde ensamblador . . . . 62
3.2.3 Funciones recursivas . . . . . . . . . . . . . . . . . . . . . . . 64
3.2.4 Funciones con muchos parmetros de entrada . . . . . . . . . 70
3.2.5 Pasos detallados de llamadas a funciones . . . . . . . . . . . . 75
3.3 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3.3.1 Mnimo de un vector . . . . . . . . . . . . . . . . . . . . . . . 76
3.3.2 Media aritmtica, macros y conteo de ciclos . . . . . . . . . . 78
3.3.3 Algoritmo de ordenacin . . . . . . . . . . . . . . . . . . . . . 80
4 E/S a bajo nivel 83

4.1 Lectura previa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
4.1.1 Libreras y Kernel, las dos capas que queremos saltarnos . . . 84
4.1.2 Ejecutar cdigo en Bare Metal . . . . . . . . . . . . . . . . . . 86
4.2 Acceso a perifricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4.2.1 GPIO (General-Purpose Input/Output) . . . . . . . . . . . . 89
4.2.2 Temporizador del sistema . . . . . . . . . . . . . . . . . . . . 95
4.3 Ejemplos de programas Bare Metal . . . . . . . . . . . . . . . . . . . 96
4.3.1 LED parpadeante con bucle de retardo . . . . . . . . . . . . . 96
4.3.2 LED parpadeante con temporizador . . . . . . . . . . . . . . . 99
4.3.3 Sonido con temporizador . . . . . . . . . . . . . . . . . . . . . 99
4.4 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
4.4.1 Cadencia variable con bucle de retardo . . . . . . . . . . . . . 101
4.4.2 Cadencia variable con temporizador . . . . . . . . . . . . . . . 101
4.4.3 Escala musical . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
5 Interrupciones hardware 103

5.1 Lectura previa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
5.1.1 El sistema de interrupciones del ARM . . . . . . . . . . . . . 104
5.1.2 Rutina de tratamiento de interrupcin . . . . . . . . . . . . . 109
5.1.3 Pasos para configurar las interrupciones . . . . . . . . . . . . 110
5.1.4 El controlador de interrupciones . . . . . . . . . . . . . . . . . 112
5.1.5 Ejemplo. Encender LED rojo a los 4 segundos . . . . . . . . . 114
5.1.6 Ejemplos de aplicacin . . . . . . . . . . . . . . . . . . . . . . 118
5.1.7 Parpadeo de todos los LEDs . . . . . . . . . . . . . . . . . . . 119
5.1.8 Control de LEDs rojos con pulsadores . . . . . . . . . . . . . . 123
5.1.9 Parpadeo secuencial de LEDs con sonido por altavoz . . . . . 127
5.1.10 Manejo de FIQs y sonidos distintos para cada LED . . . . . . 133
5.1.11 Control de luces/sonido con pulsadores en lugar temporizadores138
viii
5.2 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
5.2.1 Todo con IRQs . . . . . . . . . . . . . . . . . . . . . . . . . . 142
5.2.2 Alargar secuencia a 10 y parpadeo . . . . . . . . . . . . . . . . 142
5.2.3 Tope de secuencia y limitar sonido . . . . . . . . . . . . . . . 142
5.2.4 Reproductor de meloda sencilla . . . . . . . . . . . . . . . . . 143
A Funcionamiento de la macro ADDEXC 145

A.1 Finalidad y tipos de salto . . . . . . . . . . . . . . . . . . . . . . . . 145
A.2 Eleccin: salto corto . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
A.3 Escribir una macro . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
A.4 Codificacin de la instruccin de salto . . . . . . . . . . . . . . . . . . 147
A.5 Resultado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
B Funcionamiento de la placa auxiliar 149

B.1 Esquema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
B.2 Pinout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
B.3 Correspondencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
B.4 Funcionamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
B.5 Presupuesto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
B.6 Diseo PCB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
C Cable serie y bootloaders 155

C.1 Introduccin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
C.2 Cable USB-serie desde el ordenador de desarrollo . . . . . . . . . . . 155
C.3 Cable serie-serie que comunica dos Raspberries . . . . . . . . . . . . . 157
C.4 Reseteo automtico . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
C.5 Cdigo fuente del bootloader . . . . . . . . . . . . . . . . . . . . . . . 162
D Resistencias programables de pull-up y pull-down 169

D.1 Introduccin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
D.2 Pulsadores en la placa auxiliar . . . . . . . . . . . . . . . . . . . . . . 170
D.3 Ejemplo de aplicacin . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
D.3.1 Pulsador a masa sin cambiar configuracin . . . . . . . . . . . 170
D.3.2 Pulsador a masa cambiando configuracin . . . . . . . . . . . 172
D.3.3 Pulsador a Vcc sin cambiar configuracin . . . . . . . . . . . . 175
Bibliografa 178
ix
x
ndice de figuras
1.1 Registros de la arquitectura ARM . . . . . . . . . . . . . . . . . . . . 3

1.2 Ubicacin de datos en memoria . . . . . . . . . . . . . . . . . . . . . 5
1.3 Entorno tpico de programacin . . . . . . . . . . . . . . . . . . . . . 6
1.4 Instrucciones de desplazamiento lgico . . . . . . . . . . . . . . . . . 25
1.5 Instrucciones de desplazamiento aritmtico . . . . . . . . . . . . . . . 25
1.6 Instrucciones de rotacin . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.7 Instrucciones de rotacin con carry . . . . . . . . . . . . . . . . . . . 26
2.1 Representacin de un vector en memoria . . . . . . . . . . . . . . . . 38

2.2 (a) Formato de una matriz C con N filas y M columnas y (b) orga-
nizacin por filas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.1 Uso de la pila en una funcin . . . . . . . . . . . . . . . . . . . . . . 65

3.2 Uso de la pila en nuestra funcin . . . . . . . . . . . . . . . . . . . . 66
3.3 Mapa de pila de funcin poly3 . . . . . . . . . . . . . . . . . . . . . . 72
3.4 Mapa de funcin hipottica . . . . . . . . . . . . . . . . . . . . . . . 73
4.1 Funcionamiento de una llamada a printf . . . . . . . . . . . . . . . . 85

4.2 Colocacin de la placa auxiliar . . . . . . . . . . . . . . . . . . . . . . 89
4.3 Posicin del puerto GPIO . . . . . . . . . . . . . . . . . . . . . . . . 90
4.4 Correspondencia LEDs y GPIO . . . . . . . . . . . . . . . . . . . . . 92
4.5 Puertos LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
4.6 Otros puertos del GPIO (1 parte) . . . . . . . . . . . . . . . . . . . 94
4.7 Otros puertos del GPIO (2 parte) . . . . . . . . . . . . . . . . . . . 95
4.8 System Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
4.9 Esquema funcional del System Timer . . . . . . . . . . . . . . . . . . 97
5.1 Registro cpsr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

5.2 Registros segn modo de operacin . . . . . . . . . . . . . . . . . . . 106
5.3 Diagrama de una interrupcin . . . . . . . . . . . . . . . . . . . . . . 108
5.4 Mapa de memoria en nuestros ejemplos . . . . . . . . . . . . . . . . . 111
5.5 Interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
xi
5.6 Agrupacin de puertos de interrupciones . . . . . . . . . . . . . . . . 113
5.7 Interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
5.8 Interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
5.9 Interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
5.10 Interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
5.11 Interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
A.1 Formato de instruccin de salto . . . . . . . . . . . . . . . . . . . . . 147

A.2 Clculo del desplazamiento . . . . . . . . . . . . . . . . . . . . . . . . 148
B.1 Placa auxiliar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

B.2 Esquema del circuito . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
B.3 Pinout del puerto GPIO . . . . . . . . . . . . . . . . . . . . . . . . . 151
B.4 Correspondencia LEDs y GPIO . . . . . . . . . . . . . . . . . . . . . 152
B.5 Diseo PCB del circuito . . . . . . . . . . . . . . . . . . . . . . . . . 154
C.1 Cable USB-serie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

C.2 Dos raspberries en serie cruzado . . . . . . . . . . . . . . . . . . . . . 158
C.3 Seal de Reset donde montar el pin . . . . . . . . . . . . . . . . . . . 160
C.4 Formato de paquete XMODEM . . . . . . . . . . . . . . . . . . . . . 166
C.5 Ejemplo de transmisin . . . . . . . . . . . . . . . . . . . . . . . . . . 167
D.1 Pulsador a masa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

D.2 Resistencia interna de pull-up . . . . . . . . . . . . . . . . . . . . . . 173
D.3 Pulsador a Vcc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
D.4 Resistencia interna de pull-down . . . . . . . . . . . . . . . . . . . . . 176
xii
ndice de Tablas
1.1 Lista de familias y arquitecturas ARM . . . . . . . . . . . . . . . . . 2

1.2 Lista de atajos de teclado para editor nano . . . . . . . . . . . . . . . 16
1.3 Instrucciones de multiplicacin . . . . . . . . . . . . . . . . . . . . . . 28
5.1 Vector de interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . 105
B.1 Correspondencia entre pines y componentes . . . . . . . . . . . . . . 151

B.2 Presupuesto unitario por puesto . . . . . . . . . . . . . . . . . . . . . 153
xiii
Prlogo
El minicomputador Raspberry Pi es una placa del tamao de una tarjeta de

crdito y un precio de slo 30. El objetivo principal de sus creadores, la Funda-
cin Raspberry Pi, era promover la enseanza de conceptos bsicos de informtica
en los colegios e institutos. Sin embargo, ha terminado convirtindose tambin en
un pequeo computador de bajo coste que se destina a muy diversos usos: servidor
multimedia conectado al televisor, estacin base para domtica en el hogar, esta-
ciones meteorolgicas, servidor de discos en red para copias de seguridad, o como
un simple ordenador que puede ejecutar aplicaciones de internet, juegos, ofimtica,
etc. Esto ha llegado a ser as gracias a un vertiginoso crecimiento de la comuni-
dad de desarrolladores para Raspberry Pi, y que estos han explorado casi todas
las posibilidades para sacar el mximo partido de este ordenador de 30. Esa gran
funcionalidad y el bajo coste constituyen el principal atractivo de esta plataforma
para los estudiantes. Sin embargo, para los docentes del Dept. de Arquitectura de
Computadores, la Raspberry Pi ofrece una excusa perfecta para hacer ms amenos
y atractivos conceptos a veces complejos, y a veces tambin ridos, de asignaturas
del rea.
Este trabajo se enmarca dentro del Proyecto de Innovacin Educativa PIE13-082,
Motivando al alumno de ingeniera mediante la plataforma Raspberry Pi cuyo prin-
cipal objetivo es aumentar el grado de motivacin del alumno que cursa asignaturas
impartidas por el Departamento de Arquitectura de Computadores. La estrategia
propuesta se apoya en el hecho de que muchos alumnos de Ingeniera perciben que
las asignaturas de la carrera estn alejadas de su realidad cotidiana, y que por ello,
pierden cierto atractivo. Sin embargo, bastantes de estos alumnos han comprado o
piensan comprar un minicomputador Raspberry Pi que se caracteriza por propor-
cionar una gran funcionalidad, gracias a estar basado en un procesador y Sistema
Operativo de referencia en los dispositivos mviles. En este proyecto proponemos
aprovechar el inters que los alumnos ya demuestran por la plataforma Raspberry
Pi, para ponerlo a trabajar en pro del siguiente objetivo docente: facilitar el estudio
de conceptos y tcnicas impartidas en varias asignaturas del Departamento. Cuatro
de estas asignaturas son:
Tecnologa de Computadores: Asignatura obligatoria del mdulo de Formacin
xv
xvi Prlogo
Comn de las titulaciones de Grado en Ingeniera Informtica, Grado en Inge-

niera de Computadores y Grado en Ingeniera del Software. Es una asignatura
que se imparte en el primer curso.
Estructura de Computadores: Asignatura obligatoria del mdulo de Forma-

cin Comn de las titulaciones de Grado en Ingeniera Informtica, Grado
en Ingeniera de Computadores y Grado en Ingeniera del Software. Es una
asignatura que se imparte en el segundo curso.
Sistemas Operativos: Asignatura obligatoria del mdulo de Formacin Comn

de las titulaciones de Grado en Ingeniera Informtica, Grado en Ingeniera
de Computadores y Grado en Ingeniera del Software. Se imparte en segundo
curso.
Diseo de Sistemas Operativos: Asignatura obligatoria del mdulo de Tecno-

logas Especficas del Grado de Ingeniera de Computadores. Se imparte en
tercer curso.
En esas cuatro asignaturas, uno de los conceptos ms bsicos es el de gestin

de interrupciones a bajo nivel. En particular, en Estructura de Computadores, esos
conceptos se ilustraban en el pasado mediante prcticas en PCs con MSDOS y pro-
gramacin en ensamblador, pero el uso de ese sistema operativo ya no tiene ningn
atractivo y adems crea problemas de seguridad en los laboratorios del departa-
mento. Sin embargo, la plataforma Raspberry Pi se convierte en una herramienta
adecuada para trabajar a nivel de sistema, es econmica y ya disponemos de unida-
des suficientes para usarlas en los laboratorios (30 equipos para ser exactos).
El principal objetivo de este trabajo es la creacin de un conjunto de prcticas
enfocadas al aprendizaje de la programacin en ensamblador, en concreto del ARMv6
que es el procesador de la plataforma que se va a utilizar para el desarrollo de las
prcticas, as como al manejo a bajo nivel de las interrupciones y la entrada/salida
en dicho procesador. El aprendizaje del lenguaje ensamblador del procesador ARM
usado en la Raspberry Pi se puede completar leyendo la documentacin disponible
en [1] y haciendo los tutoriales de [2]. Para la parte ms centrada en el hardware
tambin se puede consultar la amplia documentacin disponible en internet, como
por ejemplo los tutoriales disponibles en [3] y la descripcin los modos de operacin
de los perifricos conectados al procesador ARM [4].
La presente memoria est dividida cinco captulos y cuatro apndices. De los 5
captulos, el primero es introductorio. Los dos siguientes se centran en la programa-
cin de ejecutables en Linux, tratando las estructuras de control en el captulo 2 y
las subrutinas (funciones) en el captulo 3. Los dos ltimos captulos muestran la
programacin en Bare Metal, explicando el subsistema de entrada/salida (puertos
de entrada/salida y temporizadores) de la plataforma Raspberry Pi y su manejo a
xvi
Prlogo xvii
bajo nivel en el captulo 4 y las interrupciones en el captulo 5. En los apndices

hemos aadido aspectos laterales pero de suficiente relevancia como para ser con-
siderados en la memoria, como el apendice A que explica el funcionamiento de la
macro ADDEXC, el apndice B que muestra todos los detalles de la placa auxiliar, el
apndice C que nos ensea a agilizar la carga de programas Bare Metal y por ltimo
tenemos el apndice D, que profundiza en aspectos del GPIO como las resistencias
programables.
xvii
xviii Prlogo
xviii
Captulo 1
Introduccin al ensamblador
Contenido
1.1 Lectura previa . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Caractersticas generales de la arquitectura ARM . . . . . 2
1.1.2 El lenguaje ensamblador . . . . . . . . . . . . . . . . . . . 5
1.1.3 El entorno . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.1.4 Configuracin del entorno para realizar las prcticas en casa 7
1.1.5 Aspecto de un programa en ensamblador . . . . . . . . . . 9
1.1.6 Ensamblar y linkar un programa . . . . . . . . . . . . . . 14
1.2 Enunciados de la prctica . . . . . . . . . . . . . . . . . . . 15
1.2.1 Cmo empezar . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.2 Enteros y naturales . . . . . . . . . . . . . . . . . . . . . . 20
1.2.3 Instrucciones lgicas . . . . . . . . . . . . . . . . . . . . . 23
1.2.4 Rotaciones y desplazamientos . . . . . . . . . . . . . . . . 25
1.2.5 Instrucciones de multiplicacin . . . . . . . . . . . . . . . 28
Objetivo: En esta sesin vamos a conocer el entorno de trabajo. Veremos qu

aspecto tiene un programa en ensamblador, veremos cmo funcionan los tres pro-
gramas que vamos a utilizar: el ensamblador, el enlazador (linker) y el depurador
(debugger). Del debugger slo mostraremos unos pocos comandos, que ampliaremos
en las prximas sesiones. Tambin veremos la representacin de los nmeros na-
turales y de los enteros, y el funcionamiento de algunas de las instrucciones del
ARM. Se repasarn tambin los conceptos de registros, flags e instrucciones para la
manipulacin de bits.
1
2 1.1. Lectura previa
1.1. Lectura previa

1.1.1. Caractersticas generales de la arquitectura ARM
ARM es una arquitectura RISC (Reduced Instruction Set Computer=Ordenador
con Conjunto Reducido de Instrucciones) de 32 bits, salvo la versin del core ARMv8-
A que es mixta 32/64 bits (bus de 32 bits con registros de 64 bits). Se trata de una
arquitectura licenciable, quiere decir que la empresa desarrolladora ARM Holdings
disea la arquitectura, pero son otras compaas las que fabrican y venden los chips,
llevndose ARM Holdings un pequeo porcentaje por la licencia.
El chip en concreto que lleva la Raspberry Pi es el BCM2835, se trata de un SoC
(System on a Chip=Sistema en un slo chip) que contiene adems de la CPU otros
elementos como un ncleo GPU (hardware acelerado OpenGL ES/OpenVG/Open
EGL/OpenMAX y decodificacin H.264 por hardware) y un ncleo DSP (Digital
signal processing=Procesamiento digital de seales) que es un procesador ms pe-
queo y simple que el principal, pero especializado en el procesado y representacin
de seales analgicas. La CPU en cuestin es la ARM1176JZF-S, un chip de la
familia ARM11 que usa la arquitectura ARMv6k.
Familia Arquitectura Bits Ejemplos de dispositivos

ARM1 ARMv1 32/26 Segundo procesador BBC Micro
ARM2, ARM3, Amber ARMv2 32/26 Acorn Archimedes
ARM6, ARM7 ARMv3 32 Apple Newton Serie 100
ARM8, StrongARM ARMv4 32 Apple Newton serie 2x00
ARM7TDMI, ARMv4T 32 Game Boy Advance
ARM9TDMI
ARM7EJ, ARM9E, ARMv5 32 Samsung Omnia,
ARM10E, XScale Blackberry 8700
ARM11 ARMv6 32 iPhone 3G, Raspberry Pi
Cortex-M0/M0+/M1 ARMv6-M 32
Cortex-M3/M4 ARMv7-M 32 Texas Instruments Stellaris
ARMv7E-M
Cortex-R4/R5/R7 ARMv7-R 32 Texas Instruments TMS570
Cortex-A5/A7/A8/A9 ARMv7-A 32 Apple iPad
A12/15/17, Apple A6
Cortex-A53/A57, ARMv8-A 64/32 Apple iPhone 5S
X-Gene, Apple A7
Tabla 1.1: Lista de familias y arquitecturas ARM
Las extensiones de la arquitectura ARMv6k frente a la bsica ARMv6 son mni-
cbed A. Villena, R. Asenjo, F. Corbera. DAC-UMA.

Captulo 1. Introduccin al ensamblador 3
mas por lo que a efectos prcticos trabajaremos con la arquitectura ARMv6.
Registros
La arquitectura ARMv6 presenta un conjunto de 17 registros (16 principales ms
uno de estado) de 32 bits cada uno.
Figura 1.1: Registros de la arquitectura ARM
Registros Generales. Su funcin es el almacenamiento temporal de datos. Son los

13 registros que van R0 hasta R12.
Registros Especiales. Son los ltimos 3 registros principales: R13, R14 y R15.
Como son de propsito especial, tienen nombres alternativos.
SP/R13. Stack Pointer Puntero de Pila. Sirve como puntero para al-
macenar variables locales y registros en llamadas a funciones.
LR/R14. Link Register Registro de Enlace. Almacena la direccin de
retorno cuando una instruccin BL BLX ejecuta una llamada a una
rutina.

PC/R15. Program Counter Contador de Programa. Es un registro que

indica la posicin donde est el procesador en su secuencia de instruc-
ciones. Se incrementa de 4 en 4 cada vez que se ejecuta una instruccin,
salvo que sta provoque un salto.
Registro CPSR. Almacena las banderas condicionales y los bits de control. Los
bits de control definen la habilitacin de interrupciones normales (I), interrup-
ciones rpidas (F), modo Thumb 1 (T) y el modo de operacin de la CPU.
Existen hasta 8 modos de operacin, pero por ahora desde nuestra aplicacin
slo vamos a trabajar en uno de ellos, el Modo Usuario. Los dems son modos
privilegiados usados exclusivamente por el sistema operativo.
Desde el Modo Usuario slo podemos acceder a las banderas condicionales,
que contienen informacin sobre el estado de la ltima operacin realizada
por la ALU. A diferencia de otras arquitecturas en ARMv6 podemos elegir
si queremos que una instruccin actualice o no las banderas condicionales,
poniendo una s detrs del nemotcnico 2 . Existen 4 banderas y son las
siguientes:
N. Se activa cuando el resultado es negativo.
Z. Se activa cuando el resultado es cero o una comparacin es cierta.
C. Indica acarreo en las operaciones aritmticas.
V. Desbordamiento aritmtico.
Esquema de almacenamiento
El procesador es Bi-Endian, quiere decir que es configurable entre Big Endian y
Little Endian. Aunque nuestro sistema operativo nos lo limita a Little Endian.
Por tanto la regla que sigue es el byte menos significativo ocupa la posicin ms
baja. Cuando escribimos un dato en una posicin de memoria, dependiendo de si
es byte, half word o word,... se ubica en memoria segn el esquema de la figura 1.2.
La direccin de un dato es la de su byte menos significativo. La memoria siempre se
referencia a nivel de byte, es decir si decimos la posicin N nos estamos refiriendo
al byte N-simo, aunque se escriba media palabra, una palabra,...
1
Es un modo simplificado donde las instrucciones son de 16 bits en lugar de 32 y se acceden a
menos registros (hasta r7), con la ventaja de que el cdigo ocupa menos espacio.
2
Es la forma de nombrar las instrucciones desde ensamblador, normalmente derivadas de una
abreviatura del verbo en ingls. Por ejemplo la instruccin MOV viene de move (mover)

N+3 N+3 N+3 12

N+2 N+2 N+2 34
N+1 N+1 56 N+1 56
N 78 N 78 N 78
strb r1, [r0] strh r1, [r0] str r1, [r0]
Figura 1.2: Ubicacin de datos en memoria
1.1.2. El lenguaje ensamblador

El ensamblador es un lenguaje de bajo nivel que permite un control directo de
la CPU y todos los elementos asociados. Cada lnea de un programa ensamblador
consta de una instruccin del procesador y la posicin que ocupan los datos de esa
instruccin.
Desarrollar programas en lenguaje ensamblador es un proceso laborioso. El proce-
dimiento es similar al de cualquier lenguaje compilado. Un conjunto de instrucciones
y/o datos forman un mdulo fuente. Este mdulo es la entrada del compilador, que
chequea la sintaxis y lo traduce a cdigo mquina formando un mdulo objeto. Fi-
nalmente, un enlazador (montador linker) traduce todas las referencias relativas a
direcciones absolutas y termina generando el ejecutable.
El ensamblador presenta una serie de ventajas e inconvenientes con respecto a
otros lenguajes de ms alto nivel. Al ser un lenguaje de bajo nivel, presenta como
principal caracterstica la flexibilidad y la posibilidad de acceso directo a nivel de
registro. En contrapartida, programar en ensamblador es laborioso puesto que los
programas contienen un nmero elevado de lneas y la correccin y depuracin de
stos se hace difcil.
Generalmente, y dado que crear programas un poco extensos es laborioso, el
ensamblador se utiliza como apoyo a otros lenguajes de alto nivel para 3 tipos de
situaciones:
- Operaciones que se repitan un nmero elevado de veces.
- Cuando se requiera una gran velocidad de proceso.
- Para utilizacin y aprovechamiento de dispositivos y recursos del sistema.

1.1.3. El entorno
Los pasos habituales para hacer un programa (en cualquier lenguaje) son los
siguientes: lo primero es escribir el programa en el lenguaje fuente mediante un edi-
tor de programas. El resultado es un fichero en un lenguaje que puede entender el
usuario, pero no la mquina. Para traducirlo a lenguaje mquina hay que utilizar
un programa traductor. ste genera un fichero con la traduccin de dicho programa,
pero todava no es un programa ejecutable. Un fichero ejecutable contiene el progra-
ma traducido ms una serie de cdigos que debe tener todo programa que vaya a ser
ejecutado en una mquina determinada. Entre estos cdigos comunes se encuentran
las libreras del lenguaje. El encargado de unir el cdigo del programa con el cdigo
de estas libreras es un programa llamado montador (linker) que genera el programa
ejecutable (ver la figura 1.3)
fuente1.s
ENSAMBLADOR
MONTADOR
fuente2.s CARGADOR
MEMORIA
cdigo mquina
fuente3.c (binario)
EJECUTABLE
COMPILADOR
FICHEROS FUENTE FICHEROS OBJETO
Figura 1.3: Entorno tpico de programacin
Durante el proceso de creacin de un programa se suelen producir errores. Hay

dos tipos de errores: los sintcticos o detectables en tiempo de traduccin y los
errores semnticos o detectables en tiempo de ejecucin. Los errores sintcticos son,
por ejemplo, escribir mal una instruccin o hacer una operacin entre dos tipos
de datos incompatibles. Estos errores son detectados por el traductor y se deben
solucionar para poder generar un ejecutable.
Una vez que se tiene un programa sintcticamente correcto lo podemos ejecutar,
pero sto no implica que el programa sea correcto. Todas las instrucciones pueden
ser correctas, pero se puede haber olvidado poner la condicin de salida de un bucle
(y que no termine nunca) o que sencillamente el programa no haga lo que queremos.
Estos errores slo se pueden detectar en tiempo de ejecucin. Para poder elimi-
narlos se utiliza un depurador de programas (debugger). El depurador nos permite
ejecutar el programa instruccin a instruccin y ver todos los valores que se van a
calcular, de manera que podemos encontrar los errores.
En el laboratorio utilizaremos el editor nano para crear y editar los mdulos
fuente de nuestros programas. El traductor (que en el caso de traducir de un len-

guaje ensamblador a lenguaje mquina recibe el nombre de ensamblador), el linker

y el debugger son respectivamente GNU Assembler (as), GNU Compiler Collection
(gcc) y GNU Debbuger (gdb). Todas estas herramientas forman parte de la GNU
toolchain que viene instalada por defecto en la mayora de las distribuciones ba-
sadas en Linux, en concreto Raspbian. Para obtener ms informacin sobre estos
comandos se puede recurrir a la ayuda del sistema con man as, man gcc y man gdb.
1.1.4. Configuracin del entorno para realizar las prcticas

en casa
Las instrucciones vienen detalladas en esta direccin:
http://elinux.org/RPi_Easy_SD_Card_Setup
Vamos a hacer un resumen de cmo se hara en Windows. Para otros sistemas
operativos (Linux, Mac OS) seguir las instrucciones antes mencionadas.
1. Descargamos la ltima versin de RASPBIAN en la siguiente url:

http://www.raspberrypi.org/downloads/
2. Extraemos del .zip el archivo de imagen, en nuestro caso se llama 2014-01-07-

wheezy-raspbian.img, aunque seguramente tu versin ser ms moderna.
3. Insertamos una tarjeta SD en tu PC (slot SD o adaptador USB) y nos asegu-

ramos de que funcione correctamente. Si no, la formateamos en FAT32.
4. Nos bajamos e instalamos la utilidad Win32DiskImager.

http://sourceforge.net/projects/win32diskimager
5. Ejecutamos como Administrador la utilidad anterior.
6. Dentro de la utilidad, seleccionamos el archivo de imagen anterior, 2014-01-

07-wheezy-raspbian.img
7. Seleccionamos en Device la letra de unidad que nos apareci en el paso 3.

Debemos asegurarnos de que la letra sea la correcta, de lo contrario podramos
destruir los datos de nuestro disco duro.
8. Pulsamos el botn Write y esperamos a que se complete la escritura.
9. Salimos de la utilidad y extraemos la tarjeta SD.
10. Ya estamos listos para introducir la tarjeta SD en nuestra Raspberry Pi.

De forma alternativa podemos ejecutar la imagen anterior en un emulador de

Raspberry Pi, y seguir gran parte de las prcticas con la comodidad de tu PC. Para
ello partimos del archivo de imagen obtenido en el apartado 2 de la lista anterior, y
seguimos los pasos segn [5]. Los pasos son vlidos para Windows y Linux, aunque
nosotros mostraremos slo los de Windows.
1. Descargamos el emulador QEMU desde aqu:

http://lassauge.free.fr/qemu/
2. Descargamos el siguiente ncleo o kernel desde aqu:

http://xecdesign.com/downloads/linux-qemu/kernel-qemu
3. Lanzamos la lnea de comandos o ventana de MS-DOS. Esto se hace desde

Programas->Accesorios->Smbolo del sistema o bien pulsando Windows+R
y escribiendo cmd. Una vez lanzada escribimos lo siguiente:
qemu - system - armw - kernel kernel - qemu - cpu arm1176
-m 256 -M versatilepb -no - reboot - serial stdio - append
" root =/ dev / sda2 panic = 1 rootfstype = ext4 rw init =/ bin / bash "
- hda 2014 - 01 - 07 - wheezy - raspbian.img
4. Aparece el emulador en una nueva ventana tipo terminal. Ya estaramos den-

tro de la Raspberry emulada. Una vez se muestren los mensajes de arranque
aparece el siguiente texto:
raspberrypi login :
Nos est pidiendo el nombre de usuario. Nosotros escribimos pi.
5. Luego nos piden el password, que es raspberry. En este caso y por motivos
de seguridad no se recibe respuesta visual mientras escribimos la contrasea,
ni siquiera aparecen asteriscos.
6. Una vez identificados, lo primero que hacemos es editar el archivo /etc/ld.so.preload

con el siguiente comando:
nano / etc / ld.so.preload
7. Dentro del editor ponemos un # al comienzo de la siguiente lnea:

#/ usr / lib / arm - linux - gnueabihf / libcofi_rpi.so
8. Presionamos Ctrl-X y luego y, Enter para guardar y salir.

9. Escribimos sudo halt para salir limpiamente del sistema emulado.
10. Cerramos la ventana de QEMU y creamos el siguiente archivo lanzador.bat.

qemu - system - armw - kernel kernel - qemu - cpu arm1176
-m 256 -M versatilepb -no - reboot - serial stdio - append
" root =/ dev / sda2 panic = 1 rootfstype = ext4 rw "
- hda 2014 - 01 - 07 - wheezy - raspbian.img
11. Ejecutamos el archivo lanzador.bat que acabamos de crear. Ya hemos ter-

minado. Todos los archivos que vayamos creando se almacenan en la imagen
como si se tratase de una SD real corriendo sobre una Raspberry Pi real.
1.1.5. Aspecto de un programa en ensamblador

En el listado 1.1 se muestra el cdigo de la primera prctica que probaremos. En
el cdigo hay una serie de elementos que aparecern en todos los programas y que
estudiaremos a continuacin.
Listado 1.1: Cdigo del programa intro1.s
.data
var1 : .word 3
var2 : .word 4
var3 : .word 0x1234
.text
.global main
main : ldr r1, puntero_var1 /* r1 <- & var1 */

ldr r1, [ r1 ] /* r1 <- * r1 */
ldr r2, puntero_var2 /* r2 <- & var2 */
ldr r2, [ r2 ] /* r2 <- * r2 */
ldr r3, puntero_var3 /* r3 <- & var3 */
add r0, r1, r2 /* r0 <- r1 + r2 */
str r0, [ r3 ] /* * r3 <- r0 */
bx lr
puntero_var1 : .word var1


La principal caracterstica de un mdulo fuente en ensamblador es que existe

una clara separacin entre las instrucciones y los datos. La estructura ms general
de un mdulo fuente es:
* Seccin de datos. Viene identificada por la directiva .data. En esta zona se
definen todas las variables que utiliza el programa con el objeto de reservar
memoria para contener los valores asignados. Hay que tener especial cuidado
para que los datos estn alineados en palabras de 4 bytes, sobre todo despus
de las cadenas. Alinear significa rellenar con ceros el final de un dato para que
el siguiente dato comience en una direccin mltiplo de 4 (con los dos bits
menos significativos a cero). Los datos son modificables.
* Seccin de cdigo. Se indica con la directiva .text, y slo puede contener cdigo
o datos no modificables. Como todas las instrucciones son de 32 bits no hay
que tener especial cuidado en que estn alineadas. Si tratamos de escribir en
esta zona el ensamblador nos mostrar un mensaje de error.
De estas dos secciones la nica que obligatoriamente debe existir es la seccin
.text (o seccin de cdigo). En el ejemplo 1.1 comprobamos que estn las dos.
Un mdulo fuente, como el del ejemplo, est formado por instrucciones, datos,
smbolos y directivas. Las instrucciones son representaciones nemotcnicas del juego
de instrucciones del procesador. Un dato es una entidad que aporta un valor nu-
mrico, que puede expresarse en distintas bases o incluso a travs de una cadena.
Los smbolos son representaciones abstractas que el ensamblador maneja en tiempo
de ensamblado pero que en el cdigo binario resultante tendr un valor numrico
concreto. Hay tres tipos de smbolos: las etiquetas, las macros y las constantes sim-
blicas. Por ltimo tenemos las directivas, que sirven para indicarle ciertas cosas
al ensamblador, como delimitar secciones, insertar datos, crear macros, constantes
simblicas, etc... Las instrucciones se aplican en tiempo de ejecucin mientras que
las directivas se aplican en tiempo de ensamblado.
Datos
Los datos se pueden representar de distintas maneras. Para representar nmeros
tenemos 4 bases. La ms habitual es en su forma decimal, la cual no lleva ningn
delimitador especial. Luego tenemos otra muy til que es la representacin hexade-
cimal, que indicaremos con el prefijo 0x. Otra interesante es la binaria, que emplea
el prefijo 0b antes del nmero en binario. La cuarta y ltima base es la octal, que
usaremos en raras ocasiones y se especifica con el prefijo 0. S, un cero a la izquierda
de cualquier valor convierte en octal dicho nmero. Por ejemplo 015 equivale a 13 en
decimal. Todas estas bases pueden ir con un signo menos delante, codificando el valor
negativo en complemento a dos. Para representar carcteres y cadenas emplearemos
las comillas simples y las comillas dobles respectivamente.

Smbolos
Como las etiquetas se pueden ubicar tanto en la seccin de datos como en la de
cdigo, la versatilidad que nos dan las mismas es enorme. En la zona de datos, las
etiquetas pueden representar variables, constantes y cadenas. En la zona de cdigo
podemos usar etiquetas de salto, funciones y punteros a zona de datos.
Las macros y las constantes simblicas son smbolos cuyo mbito pertenece al
preprocesador, a diferencia de las etiquetas que pertenecen al del ensamblador. Se
especifican con las directivas .macro y .equ respectivamente y permiten que el cdigo
sea ms legible y menos repetitivo.
Instrucciones
Las instrucciones del as (a partir de ahora usamos as para referirnos al ensam-
blador) responden al formato general:
Etiqueta : Nemot cnico Operando / s /* Comentario */
De estos campos, slo el nemnico (nombre de la instruccin) es obligatorio. En

la sintaxis del as cada instruccin ocupa una lnea terminando preferiblemente con
el ASCII 10 (LF), aunque son aceptadas las 4 combinaciones: CR, LF, CR LF y LF
CR. Los campos se separan entre s por al menos un carcter espacio (ASCII 32) o
un tabulador y no existe distincin entre maysculas y minsculas.
main : ldr r1, puntero_var1 /* r1 <- & var1 */
El Campo etiqueta, si aparece, debe estar formado por una cadena alfanumrica.
La cadena no debe comenzar con un dgito y no se puede utilizar como cadena
alguna palabra reservada del as ni nombre de registro del microprocesador. En el
ejemplo, la etiqueta es main:.
El campo Nemotcnico (ldr en el ejemplo) es una forma abreviada de nombrar
la instruccin del procesador. Est formado por caracteres alfabticos (entre 1 y 11
caracteres).
El campo Operando/s indica dnde se encuentran los datos. Puede haber 0, 1
ms operandos en una instruccin. Si hay ms de uno normalmente al primero se
le denomina destino (salvo excepciones como str) y a los dems fuentes, y deben
ir separados por una coma. Los operandos pueden ser registros, etiquetas, valores
inmediatos o incluso elementos ms complejos como desplazadores/rotadores o in-
dicadores de pre/post-incrementos. En cualquiera de los casos el tamao debe ser
una palabra (32 bits), salvo contadas excepciones como ldr y str donde puede ser
media palabra (16 bits) o un byte (8 bits). En el ejemplo r1 es el operando destino,
de tipo registro, y puntero_var1 es el operando fuente, una etiqueta. Tanto r1 como
puntero_var1 hacen referencia a un valor de tamao palabra (32 bits).

El campo Comentario es opcional (r1 <- &var1, en el ejemplo) y debe comenzar

con la secuencia /* y acabar con */ al igual que los comentarios multilnea en C.
No es obligatorio que estn a la derecha de las instrucciones, aunque es lo habitual.
Tambin es comn verlos al comienzo de una funcin (ocupando varias lneas) para
explicar los parmetros y funcionalidad de la misma.
Cada instruccin del as se refiere a una operacin que puede realizar el micro-
procesador. Tambin hay pseudoinstrucciones que son tratadas por el preprocesador
como si fueran macros y codifican otras instrucciones, como lsl rn, #x que codifica
mov rn, rn, lsl #x, o bien push/pop que se traducen instrucciones stm/ldm ms
complejas y difciles de recordar para el programador. Podemos agrupar el conjunto
de instrucciones del as, segn el tipo de funcin que realice el microprocesador, en
las siguientes categoras:
Instrucciones de transferencia de datos Mueven informacin entre registros

y posiciones de memoria. En la arquitectura ARMv6 no existen puertos ya
que la E/S est mapeada en memoria. Pertenecen a este grupo las siguientes
instrucciones: mov, ldr, str, ldm, stm, push, pop.
Instrucciones aritmticas. Realizan operaciones aritmticas sobre nmeros bi-

narios o BCD. Son instrucciones de este grupo add, cmp, adc, sbc, mul.
Instrucciones de manejo de bits. Realizan operaciones de desplazamiento, ro-

tacin y lgicas sobre registros o posiciones de memoria. Estn en este grupo
las instrucciones: and, tst, eor, orr, LSL, LSR, ASR, ROR, RRX.
Instrucciones de transferencia de control. Se utilizan para controlar el flujo de

ejecucin de las instrucciones del programa. Tales como b, bl, bx, blx y sus
variantes condicionales.
En esta sesin prctica se explorarn algunas de estas instrucciones. Para buscar

informacin sobre cualquiera de ellas durante las prcticas, recuerda que puedes
utilizar el manual tcnico del ARM1176JZF-S [6].
Directivas
Las directivas son expresiones que aparecen en el mdulo fuente e indican al
compilador que realice determinadas tareas en el proceso de compilacin. Son fcil-
mente distinguibles de las instrucciones porque siempre comienzan con un punto.
El uso de directivas es aplicable slo al entorno del compilador, por tanto varan
de un compilador a otro y para diferentes versiones de un mismo compilador. Las
directivas ms frecuentes en el as son:

Directivas de asignacin: Se utilizan para dar valores a las constantes o reservar

posiciones de memoria para las variables (con un posible valor inicial). .byte,
.hword, .word, .ascii, .asciz, .zero y .space son directivas que indican
al compilador que reserve memoria para las variables del tipo indicado. Por
ejemplo:
a1 : .byte 1 /* tipo byte, inicializada a 1 */
var2 : .byte A /* tipo byte, al caracter A */
var3 : .hword 25000 /* tipo hword ( 16 bits ) a 25000 */
var4 : .word 0x12345678 /* tipo word de 32 bits */
b1 : .ascii " hola " /* define cadena normal */
b2 : .asciz " ciao " /* define cadena acabada en NUL */
dat1 : .zero 300 /* 300 bytes de valor cero */
dat2 : .space 200, 4 /* 200 bytes de valor 4 */
La directiva .equ ( .set) es utilizada para asignar un valor a una constante

simblica:
.equ N, -3 /* en adelante N se sustituye por -3 */
Directivas de control: .text y .data sirven para delimitar las distintas seccio-
nes de nuestro mdulo. .align alineamiento es para alinear el siguiente dato,
rellenando con ceros, de tal forma que comience en una direccin mltiplos
del nmero que especifiquemos en alineamiento, normalmente potencia de 2.
Si no especificamos alineamiento por defecto toma el valor de 4 (alineamiento
a palabra):
a1 : .byte 25 /* definimos un byte con el valor 25 */
.align /* directiva que rellena con 3 bytes */
a2 : .word 4 /* variable alineada a tama o palabra */
.include para incluir un archivo fuente dentro del actual. .global hace visible
al enlazador el smbolo que hemos definido con la etiqueta del mismo nombre.
Directivas de operando: Se aplican a los datos en tiempo de compilacin. En

general, incluyen las operaciones lgicas &, |, , aritmticas +, -, *, /, % y de
desplazamiento <, >, <<, >>:
.equ pies, 9 /* definimos a 9 la constante pies */
.equ yardas, pies / 3 /* calculamos las yardas = 3 */
.equ pulgadas, pies * 12 /* calculamos pulgadas = 108 */
Directivas de Macros: Una .macro es un conjunto de sentencias en ensamblador

(directivas e instrucciones) que pueden aparecer varias veces repetidas en un

programa con algunas modificaciones (opcionales). Por ejemplo, supongamos

que a lo largo de un programa realizamos varias veces la operacin n2 +1 donde
n y el resultado son registros. Para acortar el cdigo a escribir podramos usar
una macro como la siguiente:
.macro CuadM1 input, aux, output
mul aux, input, input
add output, aux, # 1
.endm
Esta macro se llama CuadM1 y tiene tres parmetros (input, aux y output).
Si posteriormente usamos la macro de la siguiente forma:
CuadM1 r1, r8, r0
el ensamblador se encargar de expandir la macro, es decir, en lugar de la

macro coloca:
mul r8, r1, r1
add r0, r8, # 1
No hay que confundir las macros con los procedimientos. Por un lado, el cdigo
de un procedimiento es nico, todas las llamadas usan el mismo, mientras que
el de una macro aparece (se expande) cada vez que se referencia, por lo que
ocuparn ms memoria. Las macros sern ms rpidas en su ejecucin, pues
es secuencial, frente a los procedimientos, ya que implican un salto cuando
aparece la llamada y un retorno cuando se termina. La decisin de usar una
macro o un procedimiento depender de cada situacin en concreto, aunque
las macros son muy flexibles (ofrecen muchsimas ms posibilidades de las
comentadas aqu). Esta posibilidad ser explotada en sesiones ms avanzadas.
1.1.6. Ensamblar y linkar un programa

La traduccin o ensamblado de un mdulo fuente (nombreprograma.s) se rea-
liza con el programa Gnu Assembler, con el siguiente comando:
as -o nombreprograma.o nombreprograma.s
NOTA: tanto el comando as como el nombre del programa son sensibles a las
maysculas. Por tanto el comando debe ir en minsculas y el nombre como queramos,
pero recomendamos minsculas tambin. Las opcin -o nombreprograma.o puede
ir despus de nombreprograma.s.
El as genera un fichero nombreprograma.o.
Para montar (linkar) hay que hacer:

gcc -o nombreprograma nombreprograma.o
NOTA: Nuevamente, tanto gcc como el nombre del programa deben estar en
minsculas. Este comando es muy parecido al anterior, podemos poner si queremos
-o nombreprograma detrs de nombreprograma.o. La nica diferencia es que
el archivo no tiene extensin, que por otro lado es una prctica muy recomendable
para ejecutables en Linux.
Una vez hecho sto, ya tenemos un fichero ejecutable (nombreprograma) que
podemos ejecutar o depurar con el gdb.
1.2. Enunciados de la prctica

1.2.1. Cmo empezar
Recuerda que en laboratorio las raspberries no tienen monitor ni teclado, la nica
conexin con el mundo real es el puerto Ethernet. En el apndice C se explica otro
mecanismo para conectar.
As que antes de nada averigua cul es la direccin IP de la Raspberry Pi dentro
de la red local. Por defecto el usuario es pi y la contrasea raspberry. Suponiendo
que la direccin IP asignada es 192.168.1.42, utilizaremos ssh:
ssh pi@192 .168.1.42
Y luego introduce la contrasea. Ya conectado a la Raspberry Pi desde un PC

a travs de ssh. Todos los alumnos se conectarn con el mismo nombre de usuario,
por lo que hay que dejar limpio el directorio de trabajo antes de terminar la sesin.
Tambin es buena idea conectarte por ssh a la Raspberry que tengas en casa co-
mo acabamos de explicar, as te ahorras el tener que disponer de teclado y monitor
extra. Desde Windows puedes bajarte putty.exe en
http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html (no requiere
instalacin) y crear un acceso directo en el escritorio con el siguiente destino, cam-
biando ruta y 192.168.1.42 por lo que corresponda.
C :\ ruta \ putty.exe 192.168.1.42 -l pi - pw raspberry
Comenzaremos con el programa que hemos visto en el listado 1.1, y que se en-
cuentra en el fichero intro1.s. Edtalo con el programa nano para verlo (y practicar
un poco):
nano intro1.s

16 1.2. Enunciados de la prctica
Dentro del editor tenemos una pequea gua de comandos en la parte inferior.
Tambin podemos acceder a una ayuda ms detallada pulsando F1 dentro del editor.
Estos son los atajos de teclado ms comunes:
Atajo Funcin
Ctrl-x Salir de nano, se pide confirmacin con Y/N
Ctrl-o Salvar cambios
Ctrl-c Muestra panel con informacin sobre nmero de lnea
Alt-g Saltar a un nmero de lnea en concreto
Alt-a Seleccionar texto, mover cursores para definir regin
Ctrl-6
Alt- Copiar seleccin
Ctrl-k Cortar seleccin
Ctrl-u Pegar seleccin
Ctrl-w Buscar texto
Alt-w Repetir ltima bsqueda
Alt-r Buscar y reemplazar
Tabla 1.2: Lista de atajos de teclado para editor nano
Una vez que estis familiarizados con el nano podemos pasar al traductor:
as -o intro1.o intro1.s
Observa que cuando se traduce, aparece una lista de errores, o bien, una indi-
cacin de que el programa se ha traducido correctamente. No se puede pasar a la
etapa de montaje hasta que no se han solucionado los errores de sintaxis.
gcc -o intro1 intro1.o
De la misma forma, el montador nos informa de si todo el proceso ha sido co-

rrecto.
Una vez que hemos terminado con xito este proceso podemos pasar el programa
al gdb (GNU Debugger).
gdb intro1
El gdb ofrece muchas posibilidades, slo explicaremos las que vamos a utilizar.
Nada ms ejecutar el comando anterior, el gdb se encuentra en modo interactivo:
pi@raspberrypi ~ $ gdb intro1
GNU gdb ( GDB ) 7.4.1 - debian
Copyright ( C ) 2012 Free Software Foundation , Inc .
License GPLv3 +: GNU GPL version 3 or later
This is free software : you are free to change and redis ...

There is NO WARRANTY , to the extent permitted by law . ...

and " show warranty " for details .
This GDB was configured as " arm - linux - gnueabihf " .
For bug reporting instructions , please see :
...
Reading symbols from / home / pi / intro1 ...( no debugging sy ...
( gdb )
Podemos escribir help para acceder a la ayuda integrada, o bien irnos a la pgina
web de documentacin del gdb [7]. El primer comando a aprender es:
( gdb ) quit
Lanzamos de nuevo el depurador gdb intro1. En este momento no hay nada eje-
cutndose. Un primer paso es decirle al depurador que queremos lanzar el programa,
esto es, cargarlo en memoria y apuntar a la primera instruccin del mismo:
( gdb ) start
Temporary breakpoint 1 at 0x8390
Starting program : / home / pi / intro1
Temporary breakpoint 1, 0x00008390 in main ()
Perfecto, nos hemos saltado todos los pasos de inicializacin de la librera C y

estamos a punto de ejecutar la primera instruccin de nuestra funcin main. Veamos
qu hay all:
( gdb ) disassemble
Dump of assembler code for function main :
= > 0x00008390 : ldr r1, [ pc, # 24 ]; 0x83b0 < puntero_var1 >
0x00008394 : ldr r1, [ r1 ]
0x00008398 : ldr r2, [ pc, # 20 ]; 0x83b4 < puntero_var2 >
0x0000839c : ldr r2, [ r2 ]
0x000083a0 : ldr r3, [ pc, # 16 ]; 0x83b8 < puntero_var3 >
0x000083a4 : add r0, r1, r2
0x000083a8 : str r0, [ r3 ]
0x000083ac : bx lr
End of assembler dump.
Vemos que las instrucciones que hacan referencia a puntero_varX han cam-
biado. De momento lo ignoramos, ya lo explicaremos ms adelante. Observen que
hay una especie de flecha => apuntando a la instruccin que est apunto de eje-
cutarse (no lo ha hecho an). Antes de ejecutarla, veamos los valores de algunos
registros:

( gdb ) info registers r0 r1 r2 r3

r0 0x1 1
r1 0xbefffe04 3204447748
r2 0xbefffe0c 3204447756
r3 0x8390 33680
Podemos modificar el valor de los registros por medio de la orden print, teniendo
en cuenta los efectos adversos que esto podra ocasionar, ya que estamos alterando
el funcionamiento de nuestro programa. En este caso no pasa nada, puesto que an
no hemos ejecutado ninguna instruccin.
( gdb ) print $r0 = 2
$1 = 2
( gdb ) info registers r0 r1 r2 r3
r0 0x2 2
r1 0xbefffe04 3204447748
r2 0xbefffe0c 3204447756
r3 0x8390 33680
gdb muestra $1, que es el identificador asignado al resultado. Podemos usar

dicho identificador en nuevas expresiones y as ahorramos tiempo al teclear. En este
ejemplo no es muy til, pero lo ser si la expresin es ms compleja.
( gdb ) print $1
$2 = 2
Ahora podemos usar $2, y as sucesivamente. Bueno, ya es hora de ejecutar la

primera instruccin.
( gdb ) stepi
0x00008394 in main ()
Veamos qu ha pasado desensamblando de nuevo.

( gdb ) disassemble
= > 0x00008394 : ldr r1, [ r1 ]
0x0000839c : ldr r2, [ r2 ]
0x000083a4 : add r0, r1, r2
0x000083a8 : str r0, [ r3 ]
0x000083ac : bx lr

Observamos que la flecha => ha cambiado de posicin, apuntando ahora a la

segunda instruccin. Veamos qu le ha pasado a r1.
( gdb ) info register r1
r1 0x10558 66904
Bien, ha cambiado. De hecho esta es la direccin de puntero_var1. Compro-

bmoslo usando su nombre simblico con la sintaxis de C.
( gdb ) print & var1
$3 = ( *) 0x10558 < puntero_var1 >
Genial. Ahora veamos el contenido de dicha variable.

( gdb ) print var1
$4 = 3
Perfecto, es lo que esperbamos. Veamos el siguiente paso.

( gdb ) stepi
0x00008398 in main ()
( gdb ) disas
0x00008394 : ldr r1, [ r1 ]
= > 0x00008398 : ldr r2, [ pc, # 20 ]; 0x83b4 < puntero_var2 >
0x0000839c : ldr r2, [ r2 ]
0x000083a4 : add r0, r1, r2
0x000083a8 : str r0, [ r3 ]
0x000083ac : bx lr
Puedes emplear disas (pero no disa) como comando abreviado. En realidad to-
dos los comandos pueden abreviarse, slo que no lo hemos hecho para os resulte ms
fcil su memorizacin. A partir de ahora pondr versiones abreviadas de comandos
que ya hayamos mostrado.
( gdb ) i r r1
r1 0x3 3
Vamos bien. Ahora ejecutamos hasta la instruccin str, que seran exactamente
4 pasos.
( gdb ) si 4
0x000083a8 in main ()
( gdb ) disas


0x00008394 : ldr r1, [ r1 ]
0x0000839c : ldr r2, [ r2 ]
0x000083a4 : add r0, r1, r2
= > 0x000083a8 : str r0, [ r3 ]
0x000083ac : bx lr
Comprobamos ahora que la intruccin str funciona correctamente, inspeccionan-

do la variable var3 antes y despus.
( gdb ) p var3
$5 = 4660
( gdb ) si
0x000083ac in main ()
( gdb ) p var3
$6 = 7
Ahora ejecutemos hasta el final.

( gdb ) continue
Continuing.
[ Inferior 1 ( process 2477 ) exited with code 07 ]
El depurador nos indica que el cdigo de salida es 07. Este cdigo se lo indicamos
en el registro r0 justo antes de salir del main. Nos salimos del depurador y compro-
bamos que ejecutando el programa directamente, aunque ste no muestre ninguna
salida por pantalla, podemos verificar su cdigo de salida de la siguiente forma:
pi@raspberrypi ~ $ ./ intro1 ; echo $ ?
7
pi@raspberrypi ~ $
Ahora que ya tenemos una idea de las posibilidades del gdb vamos a repasar
unos cuantos conceptos con la ayuda de este programa.
1.2.2. Enteros y naturales

Recordemos que cuando se representa cualquier dato en memoria, ste tiene un
valor explcito (el que tiene como dato guardado en binario) y un valor implcito (el
que tiene interpretado como un tipo de dato determinado o como una instruccin).
En este apartado queremos que veais la diferencia entre el valor explcito y el valor
implcito interpretado como un natural y como un entero.

Ejercicio 1.1
Suponemos dos variables de longitud un byte var1 y var2 con los valores binarios
(00110010b ) y (11000000b ), respectivamente. Completa las casillas en blanco.
Valor explcito Valor explcito Valor implcito Valor implcito

(binario) (hexadecimal) (como un natural (como un entero
en decimal) en decimal)
var1 00110010
var2 11000000
Observa que los valores son bien diferentes segn la interpretacin (valor impl-
cito) que se les d.
Ejercicio 1.2
Calcula ahora la suma de los dos nmeros y responde en las casillas en blanco.
Valor explcito Valor explcito Valor implcito Valor implcito

(binario) (hexadecimal) (como un natural (como un entero
en decimal) en decimal)
00110010
+11000000
= = =
Cul es el valor final de los flags? N= Z= C= V=
Es el resultado final correcto interpretado como un natural?
Es el resultado final correcto interpretado como un entero?
Ahora es el momento de comprobar si hemos contestado correctamente. El cdigo

de esta parte se encuentra en el fichero intro2.s (listado 1.2).
.data
var1 : .byte 0b00110010

.align
var2 : .byte 0b11000000
.align

.text
.global main
main : ldr r1, = var1 /* r1 <- & var1 */

ldrsb r1, [ r1 ] /* r1 <- * r1 */
ldr r2, = var2 /* r2 <- & var2 */
ldrsb r2, [ r2 ] /* r2 <- * r2 */
add r0, r1, r2 /* r0 <- r1 + r2 */
bx lr
Si os fijis hemos hecho algunos cambios con respecto a intro1.s. Las variables
son de tipo byte en lugar de word, lo que nos obliga a alinear con .align despus
de cada una. Las cargamos con la instruccin ldrsb, indicando que lo que cargamos
es un byte b al que le extendemos su signo s. Hemos eliminado la variable var3,
al fin y al cabo vamos a obtener el resultado en el registro r0. Por ltimo hemos
simplificado la carga de la direccin de la variables con ldr r1, =var1, de esta forma
el ensamblador se encarga de declarar los punteros automticamente.
Ensmblalo, mntalo y sguelo con el gdb tal y como se ha explicado en la
primera parte de la prctica. Ejecuta slo las 5 primeras instrucciones. Analiza el
resultado del registro r0 y responde al siguiente ejercicio.
Ejercicio 1.3
Si interpretamos el resultado como byte

binario hexa
Si interpretamos el resultado como palabra (32 bits)

binario hexa
dem, pero si no hubisemos extendido los signos

(ldrb en lugar de ldrsb)
binario hexa
Ejercicio 1.4
Repite el ejercicio anterior, pero ahora comprobando el resultado de los flags con
lo que habas calculado en el Ejercicio 1.2. Qu ocurre?

Si observis, el registro cpsr no cambia, es el mismo antes y despus de ejecutar

la instruccin add.
( gdb ) i r cpsr
cpsr 0x60000010 1610612752
Por cierto, desde gdb no hay una forma sencilla de obtener los flags por sepa-
rado. Por suerte son fciles de interpretar a partir del valor hexadecimal de cpsr.
Convertimos a binario el nibble (dgito hexadecimal) ms significativo de cpsr, en
este caso 6 ->0110. Hacemos corresponder 0110 con la secuencia NZCV (debemos
aprenderla de memoria), con lo cual tendramos N=0, Z=1, C=1 y V=0.
La razn por la que no se actualizan los flags es que el ensamblador del ARM no
lo hace a menos que se lo indiquemos con una s detrs de la instruccin. Cambiemos
la lnea 15 del archivo intro2.s por sta.
adds r0, r1, r2 /* r0 <- r1 + r2 */
Y repetimos todos los pasos: ensamblado, enlazado y depuracin. Ahora s, com-

prueba que los flags se corresponden con los valores calculados.
1.2.3. Instrucciones lgicas

Ejercicio 1.5
Supn que tienes dos variables de tamao 1 byte, var1 y var2, con los valores
11110000b y 10101010b . Calcula el resultado de hacer una operacin AND y una
operacin OR entre las dos variables.
Valor Valor Valor

Variable (binario) (hexadecimal) (binario)
var1 11110000 11110000
var2 10101010 10101010
var1 AND var2 var1 OR var2

binario hexa binario hexa
Para comprobar el resultado tenemos el programa intro3.s.

.text
.global main
main : mov r2, # 0b11110000 /* r2 <- 11110000 */

mov r3, # 0b10101010 /* r3 <- 10101010 */

and r0, r2, r3 /* r0 <- r2 AND r3 */
orr r1, r2, r3 /* r1 <- r2 OR r3 */
mvn r4, r0 /* r4 <- NOT r0 */
mov r0, # 0x80000000
tst r0, # 0x80000000
tst r0, # 0x40000000
bx lr
Ejecuta las 4 primeras instrucciones y comprueba tus respuestas.
Ejercicio 1.6
El resultado de la instruccin and est en r0. Cul ser el resultado de hacer un
complemento a uno del mismo?
binario hexa
r0
binario hexa
r0
Ejecuta con el gdb la instruccin mvn r4, r0 y comprueba tu respuesta.
Ejercicio 1.7
La instruccin tst hace la operacin and entre un registro y una mscara y slo
acta sobre los flags. Cumplimenta las casillas en blanco, teniendo en cuenta que
el flag Z se pone a uno cuando el resultado de la and es cero, y se pone a cero en
caso contrario. Para simplificar indicamos slo los 16 bits menos significativos del
registro r0.
binario hexa
r0 10000000000000000000000000000000 80000000
tst r0, #0x80000000 Z?
tst r0, #0x40000000 Z?
Comprueba tus respuestas con ayuda del gdb, y examina el resto de flags, observa
qu ocurre con el flag N (flag de signo).

1.2.4. Rotaciones y desplazamientos

En este apartado veremos el funcionamiento de las instrucciones de desplamiento
y rotacin. Las instrucciones de desplazamiento pueden ser lgicas o aritmticas.
Los desplazamientos lgicos desplazan los bit del registro fuente introduciendo
ceros (uno o ms de uno). El ltimo bit que sale del registro fuente se almacena en el
flag C (figura 1.4). El desplazamiento aritmtico hace lo mismo, pero manteniendo
el signo (figura 1.5).
LSR C
0
C
LSL
Figura 1.4: Instrucciones de desplazamiento lgico
ASR C
0
C ASL (Hace lo mismo que el LSL)
Figura 1.5: Instrucciones de desplazamiento aritmtico
Las instrucciones de rotacin tambin desplazan, pero el bit que sale del valor
se realimenta. No existe ninguna instruccin para rotar hacia la izquierda ROL, ya
que puede simularse con la de rotacin a la derecha ROR que s existe. En estas
instrucciones el bit desplazado fuera es el mismo que el que entra, adems de dejar
una copia en el flag C (figura 1.6).
ROR C
C No existe ROL, equivalente a: ROR rx, 32-n
Figura 1.6: Instrucciones de rotacin
Las instrucciones de rotacin con el carry funcionan de manera similar, pero

el bit que entra es el que haba en el flag C y el que sale va a parar al flag C

(figura 1.7). Estas instrucciones slo rotan un bit, al contrario que las anteriores que
podan rotar/desplazar varios. La rotacin con carry a la derecha es RRX, no existe
la contrapartida RLX porque se puede sintetizar con otra instruccin ya existente
adcs. Con adcs podemos sumar un registro consigo mismo, que es lo mismo que
multiplicar por 2 o desplazar 1 bit hacia la izquierda. Si a esto le aadimos el bit de
carry como entrada y actualizamos los flags a la salida, tendremos exactamente el
mismo comportamiento que tendra la instruccin RLX.
RRX
C
adcs rx, rx, rx
Figura 1.7: Instrucciones de rotacin con carry
Tambin podemos forzar el flag C o cualquier otro flag al valor que queramos
con la siguiente instruccin.
msr cpsr_f, # valor
Donde para calcular el valor hacemos el paso inverso al explicado en gdb. Quere-
mos cambiar los flags a estos valores: N=0, Z=1, C=1 y V=0. Por el orden memori-
zado de la secuencia NZCV, calculamos el nibble binario, que es 0110. Lo pasamos
a hexadecimal 0110 ->6 y lo ponemos en la parte ms alta de la constante de 32
bits, dejando el resto a cero.
msr cpsr_f, # 0x60000000
Todas las instrucciones de rotacin en realidad son subinstrucciones que el ensam-

blador traduce a una instruccin mov. Por esa razn las he puesto en maysculas,
diferencindolas de las instrucciones reales que estn en minscula. En realidad las
dos siguientes instrucciones son totalmente equivalentes.
LSRs r0, r0, # 1
movs r0, r0, LSR # 1
Pero se tiende a escoger siempre la ms sencilla, en este caso la primera. En

prximas lecciones mostraremos la potencia que tienen las subistrucciones de des-
plazamiento/rotacin (cuando estn en mayscula mezcladas con los operandos).
Como adelanto, la siguiente instruccin multiplica por 5 el contenido de r0.

add r0, r0, r0, LSL # 2
Ejercicio 1.8
Examina atentamente el programa intro4.s (listado 1.4). Antes de ejecutarlo
completa el siguiente cuadro, despus comprueba los resultados con el gdb. Observa
la definicin de variable var1: .word 0x80000000.
Instruccin r1 (binario) C
ldr r1, [r0]
LSRs r1, r1, #1
LSRs r1, r1, #3
ldr r2, [r0]
ASRs r2, r2, #1
ASRs r2, r2, #3
ldr r3, [r0]
RORs r3, r3, #31
RORs r3, r3, #31
RORs r3, r3, #24
ldr r4, [r0]
msr cpsr_f, #0
adcs r4, r4, r4
adcs r4, r4, r4
adcs r4, r4, r4
msr cpsr_f, #0x2..
adcs r4, r4, r4

.data
var1 : .word 0x80000000
.text
.global main


ldr r1, [ r0 ] /* r1 <- * r0 */
LSRs r1, r1, # 1 /* r1 <- r1 LSR #1 */
LSRs r1, r1, # 3 /* r1 <- r1 LSR #3 */
ldr r2, [ r0 ] /* r2 <- * r0 */
ASRs r2, r2, # 1 /* r2 <- r2 ASR #1 */
ASRs r2, r2, # 3 /* r2 <- r2 ASR #3 */
ldr r3, [ r0 ] /* r3 <- * r0 */
RORs r3, r3, # 31 /* r3 <- r3 ROL #1 */
RORs r3, r3, # 31 /* r3 <- r3 ROL #1 */
RORs r3, r3, # 24 /* r3 <- r3 ROL #8 */
ldr r4, [ r0 ] /* r4 <- * r0 */
msr cpsr_f, # 0 /* C = 0 */
adcs r4, r4, r4 /* rotar izda carry */
msr cpsr_f, # 0x20000000 /* C=1 */
bx lr
1.2.5. Instrucciones de multiplicacin

Las instrucciones de multiplicacin admiten muchas posibilidades, debido a que
es una operacin en la cual el resultado tiene el doble de bits que cada operando.
En la siguiente tabla vemos las 5 instrucciones de multiplicacin que existen.
Instruccin Bits Nombre

mul 32=32x32 Multiplicacin truncada
umull 64=32x32 Multiplicacin sin signo de 32bits
smull 64=32x32 Multiplicacin con signo de 32bits
smulw* 32=32x16 Multiplicacin con signo de 32x16bits
smul** 32=16x16 Multiplicacin con signo de 16x16bits
Tabla 1.3: Instrucciones de multiplicacin
La instruccin mul realiza una multiplicacin truncada, es decir, nos quedamos

con los 32 bits inferiores del resultado. Como el signo del resultado es el bit ms
significativo el cual no obtenemos, esta multiplicacin es vlida tanto para operandos
naturales (sin signo) como para enteros (con signo). En el ejemplo de abajo r0 =
parte_baja(r1*r2):
mul r0, r1, r2

Las dos siguientes multiplicaciones (umull y smull) son largas, por eso la l del
final, donde el resultado es de 64 bits. Si los operandos son naturales escogemos la
multiplicacin sin signo (unsigned) umull. Por el contrario, si tenemos dos enteros
como factores hablamos de multiplicacin con signo (signed) smull. En ambos ejem-
plos la parte baja del resultado se almacena en r0, y la parte alta en r1. Para hacer
que r1:r0 = r2*r3:
umull r0, r1, r2, r3
smull r0, r1, r2, r3
Ahora veamos smulw*. Es con signo, y el asterisco puede ser una b para selec-
cionar la parte baja del registro del segundo factor, o una t para seleccionar la alta.
Segn el ejemplo r0 = r1*parte_baja(r2).
smulwb r0, r1, r2
Por ltimo tenemos smul** tambin con signo, donde se seleccionan partes alta
o baja en los dos factores, puesto que ambos son de 16 bits. En el ejemplo r0 =
parte_alta(r1)*parte_baja(r2).
smultb r0, r1, r2
En los dos ltimos tipos smulw* y smul** no se permite el sufijo s para actualizar
los flags.
Ejercicio 1.9
Completa los recuadros en blanco con los resultados en hexadecimal emplean-
do calculadora. Luego ensambla el listado 1.5 y comprueba mediante gdb que los
clculos anteriores son correctos.
Producto Factor1 Factor2

mul
umull
smull
smuwb
smutt

.data
var1 : .word 0x12345678
var2 : .word 0x87654321

var3 : .word 0x00012345
.text
.global main
ldr r1, = var2 /* r1 <- & var2 */
ldr r2, = var3 /* r2 <- & var3 */
ldrh r3, [ r0 ] /* r3 <- baja (* r0 ) */
ldrh r4, [ r1 ] /* r4 <- baja (* r1 ) */
muls r5, r3, r4 /* r5 <- r3 * r4 */
ldr r3, [ r0 ] /* r3 <- * r0 */
ldr r4, [ r1 ] /* r4 <- * r1 */
umull r5, r6, r3, r4 /* r6 : r5 <- r3 * r4 */
smull r5, r6, r3, r4 /* r6 : r5 <- r3 * r4 */
ldrh r3, [ r0 ] /* r3 <- baja (* r0 ) */
ldr r4, [ r2 ] /* r4 <- * r2 */
smulwb r5, r3, r4 /* r5 <- r3 * baja ( r4 ) */
smultt r5, r3, r4 /* r5 <- alta ( r3 )* alta ( r4 ) */
Captulo 2
Tipos de datos y sentencias de alto

nivel
Contenido
2.1 Lectura previa . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.1.1 Modos de direccionamiento del ARM . . . . . . . . . . . . 31
2.1.2 Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . 36
2.1.3 Instrucciones de salto . . . . . . . . . . . . . . . . . . . . 38
2.1.4 Estructuras de control de alto nivel . . . . . . . . . . . . . 42
2.1.5 Compilacin a ensamblador . . . . . . . . . . . . . . . . . 43
2.1.6 Ejercicios propuestos. . . . . . . . . . . . . . . . . . . . . 46
2.2 Enunciados de la prctica . . . . . . . . . . . . . . . . . . . 48
2.2.1 Suma de elementos de un vector . . . . . . . . . . . . . . 48
Objetivo: En esta sesin repasaremos cmo se representa la informacin en la

memoria del computador: veremos la definicin en ensamblador de punteros, vectores
y matrices. Tambin veremos cmo se programan las estructuras de alto nivel del
tipo if-else y los bucles for y while.
2.1. Lectura previa

2.1.1. Modos de direccionamiento del ARM
En la arquitectura ARM los accesos a memoria se hacen mediante instrucciones
especficas ldr y str (luego veremos las variantes ldm, stm y las preprocesadas push
31
y pop). El resto de instrucciones toman operandos desde registros o valores inme-

diatos, sin excepciones. En este caso la arquitectura nos fuerza a que trabajemos de
un modo determinado: primero cargamos los registros desde memoria, luego proce-
samos el valor de estos registros con el amplio abanico de instrucciones del ARM,
para finalmente volcar los resultados desde registros a memoria. Existen otras ar-
quitecturas como la Intel x86, donde las instrucciones de procesado nos permiten
leer o escribir directamente de memoria. Ningn mtodo es mejor que otro, todo
es cuestin de diseo. Normalmente se opta por direccionamiento a memoria en
instrucciones de procesado en arquitecturas con un nmero reducido de registros,
donde se emplea la memoria como almacn temporal. En nuestro caso disponemos
de suficientes registros, por lo que podemos hacer el procesamiento sin necesidad de
interactuar con la memoria, lo que por otro lado tambin es ms rpido.
Direccionamiento inmediato. El operando fuente es una constante, formando
parte de la instruccin.
mov r0, # 1
add r2, r3, # 4
Direccionamiento inmediato con desplazamiento o rotacin. Es una varian-

te del anterior en la cual se permiten operaciones intermedias sobre los regis-
tros.
mov r1, r2, LSL # 1 /* r1 <- ( r2 * 2 ) */
mov r1, r2, LSL # 2 /* r1 <- ( r2 * 4 ) */
mov r1, r3, ASR # 3 /* r1 <- ( r3 / 8 ) */
Estas instrucciones tambin se usan implicitamente para la creacin de cons-

tantes, rotando o desplazando constantes ms pequeas de forma transparente
al usuario. Como todas las instrucciones ocupan 32 bits, es tcnicamente im-
posible que podamos cargar en un registro cualquier constante de 32 bits con
la instruccin mov. Por esta razn cuando se necesita cargar una constante
ms compleja en un registro (como una direccin a una variable de memoria)
no podemos hacerlo con la instruccin mov, tenemos que recurrir a ldr con
direccionamiento a memoria.
Un mtodo para determinar si una constante entra o no en una ins-
truccin mov es pasar la constante a binario y quitar los ceros de la iz-
quierda y de la derecha y contar el nmero de bits resultante. Si el n-
mero de bits es menor o igual que 8, la constante entra en una instruc-
cin mov. Por ejemplo la constante 0x00354000 al pasarla a binario sera
00000000001101010100000000000000. Eliminando los ceros de delante y de-
trs tenemos 11010101, que son 8 bits y por tanto cabe en un mov.
Este mtodo tiene excepciones. Una de ellas est en los nmeros negativos,
que en lugar de quitar ceros a izquierda y derecha quitamos unos. Por ejemplo

Captulo 2. Tipos de datos y sentencias de alto nivel 33
la constante 0xFFFBFBFF en binario es 11111111111110111111101111111111

y quitando los unos a ambos lados queda 011111110, que son 9 bits y por
tanto este caso requiere un ldr.
La otra excepcin est en el hecho de que las constantes de 32 bits no slo
se crean desplazando constantes de 8, el ensamblador tambin puede recurrir
a rotaciones circulares para crearlas. En casos complejos como ste a veces es
ms prctico probar con mov y si no salta ningn error en el ensamblado es
porque cabe con mov. Por ejemplo:
mov r1, # 0x80000020
Ensamblamos y vemos que no da problemas. Sin embargo con esta otra.

mov r1, # 0x80000040
El ensamblador nos muestra el siguiente error.

ejem.s : Assembler messages :
ejem.s : 10 : Error : invalid constant ( 80000040 ) after fixup
Direccionamiento a memoria, sin actualizar registro puntero. Es la forma

ms sencilla y admite 4 variantes. Despus del acceso a memoria ningn re-
gistro implicado en el clculo de la direccin se modifica.
[Rx, #+inmediato]
[Rx, #-inmediato]
Simplemente aade (o sustrae) un valor inmediato al registro dado para
calcular la direccin. Es muy til para acceder a elementos fijos de un
array, ya que el desplazamiento es constante. Por ejemplo si tenemos r1
apuntando a un array de enteros de 32 bits int a[] y queremos poner
a 1 el elemento a[3], lo hacemos as:
mov r2, # 1 /* r2 <- 1 */
str r2, [ r1, #+ 12 ] /* *( r1 + 12 ) <- r2 */
Ntese que hemos multiplicado por 4 el desplazamiento porque cada

elemento del array son 4 bytes. El desplazamiento no puede ser mayor
de 12 bits, por lo que nuestro rango est lmitado entre [Rx, #-4095]
y [Rx, #+4095].
[Rx, +Ry]
[Rx, -Ry]
Parecido al anterior pero en lugar de un inmediato emplea otro registro.

til en el caso de queramos mantener fijo el registro Rx y movernos con

Ry, o bien para acceder a desplazamientos mayores a 4095. El mismo

ejemplo de arriba utilizando esta variante sera:
mov r2, # 1 /* r2 <- 1 */
mov r3, # 12 /* r3 <- 12 */
str r2, [ r1, + r3 ] /* *( r1 + r3 ) <- r2 */
[Rx, +Ry, operacin_desp #inmediato]

[Rx, -Ry, operacin_desp #inmediato]
En este caso aplicamos una operacin de desplazamiento o rotacin sobre

el segundo registro Ry. Muy til en caso de arrays o estructuras con ele-
mentos de longitud potencia de 2, ya que podemos indexar directamente.
El mismo ejemplo de antes:
mov r2, # 1
mov r3, # 3
str r2, [ r1, + r3, LSL # 2 ]
Ntese cmo accedemos a a[3] directamente con el valor del ndice, 3.

Direccionamiento a memoria, actualizando registro puntero. En este modo
de direccionamiento, el registro que genera la direccin se actualiza con la pro-
pia direccin. De esta forma podemos recorrer un array con un slo registro
sin necesidad de hacer el incremento del puntero en una instruccin aparte.
Hay dos mtodos de actualizar dicho registro, antes de ejecutar la instruccin
(preindexado) o despus de la misma (postindexado). Los tres siguientes tipos
son los postindexados.
[Rx], #+inmediato
[Rx], #-inmediato
Una notacin muy parecida a la versin que no actualiza registro, la
nica diferencia es que la constante de desplazamiento queda fuera de
los corchetes. Presenta el mismo lmite de hasta 4095. Este ejemplo pone
a cero los 3 primeros elementos a[0], a[1], a[2] del array:
mov r2, #0 /* r2 <- 0 */
str r2, [ r1 ] , #+ 4 /* a [ 0 ] <- r2 */
str r2, [ r1 ] , #+ 4 /* a [ 1 ] <- r2 */
str r2, [ r1 ] , #+ 4 /* a [ 2 ] <- r2 */
[Rx], +Ry
[Rx], -Ry
Igual que antes pero con registro en lugar de inmediato.

[Rx], +Ry, operacin_desp #inmediato

[Rx], -Ry, operacin_desp #inmediato
Ntese que en todos los modos postindexados encerramos entre llaves

el primer registro, que es el que se va a utilizar en la instruccin de
lectura o escritura en memoria. Es decir primero cargamos de [Rx] y
luego actualizamos Rx con el valor que corresponda. Esta instruccin:
ldr r2, [ r1 ] , + r3, LSL # 2
Se puede desglosar en estas otras dos, cuyo comportamiento es exacta-

mente el mismo:
ldr r2, [ r1 ]
add r1, r1, r3, LSL # 2
Ya hemos visto la notacin postindexada. Veamos ahora los tres modos

preindexados.
[Rx, #+inmediato]!
[Rx, #-inmediato]!
La idea en todos los casos es encerrar entre corchetes la direccin que se
va a usar en la instruccin. Para diferenciarlo del caso que no actualiza
el registro le aadimos un ! al final.
Este modo es muy til en casos que queramos reusar en una futura
instruccin la direccin que hemos calculado. En este ejemplo duplicamos
el valor que se encuentra en a[3]:
ldr r2, [ r1, #+ 12 ]!
add r2, r2, r2
str r2, [ r1 ]
[Rx, +Ry]!
[Rx, -Ry]!
Similar al anterior pero usando Ry en lugar de inmediato.

[Rx, +Ry, operacin_desp #inmediato]!
[Rx, -Ry, operacin_desp #inmediato]!
Tercer y ltimo caso de direccionamiento preindexado. Al igual que an-

tes, desgloso en dos instrucciones para ver el funcionamiento exacto:
ldr r2, [ r1, + r3, LSL # 2 ]!

Equivale a esto.
add r1, r1, r3, LSL # 2
ldr r2, [ r1 ]
O bien a esto otro.

ldr r2, [ r1, + r3, LSL # 2 ]
add r1, r1, r3, LSL # 2
2.1.2. Tipos de datos
Tipos de datos bsicos. En la siguiente tabla se recogen los diferen-

tes tipos de datos bsicos que podrn aparecer en los ejemplos, as como su
tamao y rango de representacin.
ARM Tipo en C bits Rango

.byte unsigned char 8 0 a 255
(signed) char 8 -128 a 127
.hword unsigned short int 16 0 a 65.535
.short (signed) short int 16 -32.768 a 32767
.word unsigned int 32 0 a 4294967296
.int (signed) int 32 -2147483648 a 2147483647
unsigned long int 32 0 a 4294967296
(signed) long int 32 -2147483648 a 2147483647
.quad unsigned long long 64 0 a 264
(signed) long long 64 -2 a 263 -1
63
Ntese como en ensamblador los tipos son neutrales al signo, lo impor-

tante es la longitud en bits del tipo. La mayora de las instrucciones (salvo
multiplicacin) hacen la misma operacin tanto si se trata de un nmero na-
tural como si es entero en complemento a dos. Nosotros decidiremos el tipo
mediante las constantes que pongamos o segn los flags que interpretemos del
resultado de la operacin.
Punteros. Un puntero siempre ocupa 32 bits y contiene una direccin de memoria.

En ensamblador no tienen tanta utilidad como en C, ya que disponemos de registros
de sobra y es ms costoso acceder a las variables a travs de los punteros que direc-
tamente. En este ejemplo acceder a la direccin de var1 nos cuesta 2 ldrs a travs
del puntero, mientras que directamente se puede hacer con uno slo.

.data
var1 : .word 3
.text
.global main
main : ldr r0, = puntero_var1
ldr r1, [ r0 ]
ldr r2, [ r1 ]
ldr r3, = var1
bx lr
Observamos cmo el valor de r3 es el mismo que el de r1.

( gdb ) ni 4
0x000083a0 in main ()
( gdb ) i r r0 r1 r2 r3
r0 0x1054c 66892
r1 0x10548 66888
r2 0x3 3
r3 0x10548 66888
Incluso en tipos que en C estn basados en punteros como las cadenas, en en-
samblador no es necesario tenerlos almacenados en memoria puesto que podemos
obtener dicho valor en un registro con una nica instruccin ldr.
Vectores. Todos los elementos de un vector se almacenan en un nico bloque de
memoria a partir de una direccin determinada. Los diferentes elementos se alma-
cenan en posiciones consecutivas, de manera que el elemento i est entre los i-1 e
i+1 (figura 2.1). Los vectores estn definidos siempre a partir de la posicin 0. El
propio ndice indica cuntos elementos hemos de desplazarnos respecto del comienzo
del primer elemento (para acceder al elemento cero hemos de saltarnos 0 elementos,
para acceder al elemento 1 hemos de saltarnos un elemento, etc...; En general, para
acceder al elemento con ndice i hemos de saltarnos los i elementos anteriores).
Dado un vector int v[N];, todos los elementos se encuentran en posiciones
consecutivas a partir de la direccin de v[0] (puesto que son int, en este ejemplo,
cada elemento ocupa 4 bytes). Por lo tanto, el acceso al elemento v[i] se consigue
aplicando la siguiente expresin.
v[i] = Md [@v[0] + i 4] (2.1)

Con @v[0] nos referimos a la direccin en memoria del elemento v[0]. Con Md [ ]
notamos el acceso a memoria para la lectura/escritura de un dato (el nmero de

bytes de memoria implicado depender del tipo de datos declarado). Cuando nos
queramos refererir al acceso a memoria para la obtencin de un puntero, lo notaremos
como Mref [ ].
v[n-1]
v[n-2]
v[n-3]
N elementos, si cada elemento
... ocupa B bytes, N*B bytes
v[1]
@v[0] v[0]
Figura 2.1: Representacin de un vector en memoria
Matrices bidimensionales. Una matriz bidimensional de NM elementos se al-

macena en un nico bloque de memoria. Interpretaremos una matriz de NM como
una matriz con N filas de M elementos cada una. Si cada elemento de la matriz
ocupa B bytes, la matriz ocupar un bloque de M N B bytes (ver figura 2.2(a)).
Dentro de este bloque, los elementos se almacenan por filas. Primero se guardan
todos los elementos de la fila 0, despus todos los de la fila 1, etc. como se ve en la
figura 2.2(b).
Por lo tanto, para acceder al elemento mat[i][j] hemos de saltar i filas com-
pletas (de M elementos de B bytes) y despus j elementos de B bytes (suponiendo
una matriz de enteros, B = 4 bytes). Es decir, la frmula para obtener el elemento
mat[i][j] ser:
mat[i][j] = Md [@mat + ((i M ) + j) B] (2.2)
2.1.3. Instrucciones de salto

Las instrucciones de salto pueden producir saltos incondicionales (b y bx) o
saltos condicionales. Cuando saltamos a una etiqueta empleamos b, mientras que
si queremos saltar a un registro lo hacemos con bx. La variante de registro bx la
solemos usar como instruccin de retorno de subrutina, raramente tiene otros usos.
En los saltos condicionales aadimos dos o tres letras a la (b/bx), mediante las
cuales condicionamos si se salta o no dependiendo del estado de los flags. Estas
condiciones se pueden aadir a cualquier otra instruccin, aunque la mayora de las
veces lo que nos interesa es controlar el flujo del programa y as ejecutar o no un
grupo de instrucciones dependiendo del resultado de una operacin (reflejado en los
flags).

a) int mat[N][M];
fila i NxM
elementos
N NxMxB
bytes
columna j
@mat
b)
mat[N-1,*]
fila N-1
mat[N-2,M-1]
mat[N-2,M-2]
mat[N-2,*]
fila N-2
mat[N-2,M-3]
mat[N-2,0]
...
mat[0,*]
fila 0
Figura 2.2: (a) Formato de una matriz C con N filas y M columnas y (b) organizacin
por filas
La lista completa de condiciones es sta:
EQ (equal, igual). Cuando Z est activo (Z vale 1).
NEQ (not equal, igual). Cuando Z est inactivo (Z vale 0).
MI (minus, negativo). Cuando N est activo (N vale 1).
PL (plus, positivo o cero). Cuando N est inactivo (N vale 0).
CS/HS (carry set/higher or same, carry activo/mayor o igual). Cuando C est

activo (C vale 1).

CC/LO (carry clear/lower, carry inactivo/menor). Cuando C est inactivo (C

vale 0).
VS (overlow set, desbordamiento activo). Cuando V est activo (V vale 1).
VC (overlow clear, desbordamiento inactivo). Cuando V est inactivo (V vale

0).
GT (greater than, mayor en complemento a dos). Cuando Z est inactivo y N=V

(Z vale 0, N vale V).
LT (lower than, menor en complemento a dos). Cuando N!=V (N vale not V).
GE (greater or equal, mayor o igual en complemento a dos). Cuando N=V (N

vale V).
LE (lower or equal, menor o igual en complemento a dos). Cuando Z est

activo y N!=V (Z vale 1, N vale not V).
HI (higher, mayor). Cuando C est activo y Z inactivo (C vale 1, Z vale 0).
LS (lower or same, menor o igual). Cuando C est inactivo Z activo (C vale

0 Z vale 1).
Por ejemplo, la instruccin beq destino_salto producir un salto a la instruc-

cin indicada por la etiqueta destino_salto si y slo si el bit de estado cero est
activo (Z=1), y en caso contrario (Z=0) no interrumpir el flujo secuencial de ins-
trucciones. Previo a un salto condicional, el registro de flags debe ser actualizado
mediante alguna instruccin aritmtica (adds, subs, cmp, . . . ) o lgica (ands, orrs,
tst, . . . ). En la mayora de los casos tenemos que aadir el sufijo s a una instruccin
normal add, para forzar que la nueva instruccin adds actualice los flags.
Un aspecto muy peculiar de la arquitectura ARM es que las llamadas a subrutinas
se hacen mediante un sencillo aadido a la instruccin de salto. La instruccin bl
(tambin blx) hace una llamada a una subrutina, mediante un salto a la subrutina
y escribiendo en el registro lr la direccin de la siguiente instruccin.
main : mov r1, # 1
mov r2, # 2
bl subrut
mov r4, # 4 /* Siguiente instrucci n */
...
subrut : mov r3, # 3

bx lr

Si seguimos el flujo del programa primero cargamos r1 a 1, luego r2 a 2 y lo

siguiente que hay es una llamada a subrutina. En dicha llamada el procesador carga
en lr la direccin de la siguiente instruccin mov r4, #4 y salta a la etiqueta
subrut. Se ejecuta el mov r3, #3 de la subrutina y despus bx lr que vendra
a ser la instruccin de retorno. Es decir, salimos de la subrutina retomando el flujo
del programa principal, ejecutando mov r4, #4.
Este sencillo esquema vale para un slo nivel de subrutinas, es decir, dentro de
subrut no podemos llamar a otra subrutina porque sobreescribimos el valor del
registro lr. La solucin para extender a cualquier nmero de niveles es almacenar
el registro lr en pila con las instrucciones push y pop.
main : mov r1, # 1
mov r2, # 2
bl nivel1
mov r5, # 5 /* Siguiente instrucci n */
...
nivel1 : push { lr }
mov r3, # 3
bl nivel2
pop { lr }
bx lr
nivel2 : mov r4, # 4

bx lr
Como veis, en el ltimo nivel (nivel2) podemos ahorrarnos el tener que alma-
cenar y recuperar lr en la pila.
Las instrucciones de salto en la arquitectura ARM abarcan una zona muy ex-
tensa, hasta 64 Mb (32 Mb hacia adelante y otros 32 Mb hacia atrs). Estos lmites
podemos justificarlos atendiendo al formato de instruccin que podemos ver en el
apndice A. El cdigo de operacin ocupa 8 de los 32 bits, dejndonos 24 bits para
codificar el destino del salto. En principio con 24 bits podemos direccionar 16 Mb
[223 1, 223 1], sin embargo la arquitectura ARM se aprovecha del hecho de que
las instrucciones estn alineadas a direcciones mltiplo de 4 (en binario acaban en
00), por lo que el rango real es de 64 Mb [225 1, 225 1]
En caso de necesitar un salto mayor recurrimos a la misma solucin de la carga
de inmediatos del mov, solo que el registro a cargar es el pc.
ldr pc, = etiqueta

2.1.4. Estructuras de control de alto nivel

En este punto veremos cmo se traducen a ensamblador las estructuras de control
de alto nivel que definen un bucle (for, while, . . . ), as como las condicionales
(if-else).
Las estructuras for y while se pueden ejecutar un mnimo de 0 iteraciones (si
la primera vez no se cumple la condicin). La traduccin de las estructuras for y
while se puede ver en los listados 2.1 y 2.2.
Para programar en ensamblador estas estructuras se utilizan instrucciones de
salto condicional. Previo a la instruccin de salto es necesario evaluar la condicin
del bucle o de la sentencia if, mediante instrucciones aritmticas o lgicas, con el
fin de actualizar los flags de estado. La traduccin de la estructura if est en los
listados 2.3 y 2.4.
Listado 2.1: Estructura del for y while en C (tipos1.c)
int vi , vf , i ;
for ( i = vi ; i <= vf ; i ++ ){
/* Cuerpo del bucle */
}
i = vi ;
while ( i <= vf ){
/* Cuerpo del bucle */
i ++;
}
Listado 2.2: Traduccin de las estructuras for y while. Hemos supuesto que el valor
inicial est en la variable vi y el valor final en la variable vf y se ha utilizado el
registro r1 como ndice de las iteraciones i.
ldr r1, = vi
ldr r1, [ r1 ]
ldr r2, = vf
ldr r2, [ r2 ]
bucle : cmp r1, r2
bhi salir
/* Cuerpo
del
bucle */
add r1, r1, # 1
b bucle
salir :

Listado 2.3: Estructura if en C (tipos2.c)

int a , b ;
if ( a == b ){
/* C digo entonces */
}
else {
/* C digo sino */
}
Listado 2.4: Traduccin de la estructura if

ldr r1, = a
ldr r1, [ r1 ]
ldr r2, = b
ldr r2, [ r2 ]
cmp r1, r2
bne sino
entonces :
/* C digo entonces */
b final
sino :
/* C digo sino */
final : ...
2.1.5. Compilacin a ensamblador

Para acabar la teora veamos cmo trabaja un compilador de C real. Normal-
mente los compiladores crean cdigo compilado (archivos .o) en un nico paso. En
el caso de gcc este proceso se hace en dos fases: en una primera se pasa de C a
ensamblador, y en una segunda de ensambladador a cdigo compilado (cdigo m-
quina). Lo interesante es que podemos interrumpir justo despus de la compilacin
y ver con un editor el aspecto que tiene el cdigo ensamblador generado a partir del
cdigo fuente en C.
Vemoslo con un ejemplo.
Listado 2.5: Cdigo del programa tipos3.c
# include < stdio .h >
void main ( void ){
int i ;

for ( i = 0; i <5; i ++ ){
printf ( " %d \ n " , i );
}
Despus de crear el fichero tipos3.s, lo compilamos con este comando.

gcc - Os -S -o tipos3a.s tipos3.c
Con el parmetro -S forzamos la generacin del .s en lugar del .o y con -Os le

indicamos al compilador que queremos optimizar en tamao, es decir que queremos
cdigo ensamblador lo ms pequeo posible, sin importar el rendimiento del mismo.
El cdigo ensamblador resultante est un poco sucio, lleno de directivas super-
fluas, con punteros a variables e instrucciones no simplificadas por el preprocesador.
Tras limpiarlo quedara as.
Listado 2.6: Cdigo del programa tipos3a.s
.data
var1 : .asciz " %d \ 012 "
.text
.global main
main : push { r4, lr }
mov r4, # 0
.L2 : mov r1, r4
ldr r0, = var1
add r4, r4, # 1
bl printf
cmp r4, # 5
bne .L2
pop { r4, pc }
El carcter \n se ha transformado en octal \012 puesto que el ensamblador no

entiende de secuencias de escape. La instrucciones push y pop son la versin simple
de stmfd y ldmfd que veremos ms adelante. Ntese que la funcin no acaba con el
tpico bx lr. Se trata de una optimizacin que consigue reducir de dos instrucciones
a una. Es decir, estas dos instrucciones:
pop { r4, lr }
bx lr

Se simplifican a:
pop { r4, pc }
En general no vamos a emplear este tipo de optimizaciones en las prcticas,

puesto que dificultan la legibilidad del cdigo.
El resto del cdigo es sencillo de seguir. El registro r4 hace la funcin del contador
i del bucle, y la salida por pantalla se produce mediante una llamada a la funcin
printf bl printf. Los parmetros se los pasamos a printf mediante r0 y r1 y son
un puntero a la cadena a imprimir %d\n y el entero que le vamos a pasar. El porqu
se usan estos registros para pasar parmetros (y el hecho de haber almacenado r4
en pila) responde a la convencin AAPCS que veremos con ms detenimiento en
el siguiente captulo.
Veamos qu ocurre cuando le indicamos al compilador que queremos optimizar
al mximo en velocidad (la escala va del 0 al 3) el mismo cdigo en C:
gcc - O3 -S -o tipos3b.s tipos3.c
Tras simplificar, el fichero en ensamblador generado sera ste:

Listado 2.7: Cdigo del programa tipos3b.s
.data
var1 : .asciz " %d \ 012 "
.text
.global main
mov r1, # 0
ldr r4, = var1
mov r0, r4
bl printf
mov r0, r4
mov r1, # 1
bl printf
mov r0, r4
mov r1, # 2
bl printf
mov r0, r4
mov r1, # 3
bl printf
mov r0, r4
mov r1, # 4
pop { r4, lr }
b printf

Observamos que el bucle como tal ha desaparecido. En realidad lo que ha ocurrido

es que el compilador ha empleado una tcnica agresiva de optimizacin llamada loop
unrolling o desenrollamiento de bucle, que consiste en sustituir mediante repeticiones
del cuerpo del bucle, de tal forma que no perdemos tiempo comparando ni haciendo
el salto condicional. En este caso empleamos tantas repeticiones como iteraciones
tiene el bucle, aunque normalmente se llega hasta un lmite de repeticiones. De no
ser as el ejecutable se volvera excesivamente grande.
Por ltimo sealar que de nuevo se ha optimizado el final de la funcin, aunque
de otra forma distinta al caso anterior. La ltima iteracin debera ser as:
mov r0, r4
mov r1, # 4
bl printf
pop { r4, lr }
bx lr
Se deja como ejercicio explicar porqu pop r4, lr y b printf primero llama a
printf y luego retorna al SO.
2.1.6. Ejercicios propuestos.

Ejercicio 2.1
Basndonos en los ejemplos anteriores, escribe un bucle for que imprima los 50
primeros nmeros pares naturales en orden inverso (desde 100 hasta 2 en pasos de
2). Una vez hecho esto, aplica desenrollamiento de bucle de tal forma que el salto
condicional se ejecute 10 veces, con 5 repeticiones cada vez.
Ejercicio 2.2
Escribe el cdigo ensamblador correspondiente a una estructura if en la que no
exista la rama de else.

Ejercicio 2.3
Escribe en ensamblador un cdigo equivalente a ste. Primero haciendo uso de
la instruccin ands y un registro auxiliar, luego simplifica con la instruccin tst.
for ( i= 0; i<10; i++ ){

if( i&1 )
printf("%d es impar\n", i);
else
printf("%d es par\n", i);
}
Ejercicio 2.4
Escribe en ensamblador la estructura de alto nivel switch, aplicndola al si-
guiente ejemplo en C.

for ( i= 1950; i<2015; i++ ){

switch( i&3 ){
case 0: printf("En %d hubo olimpiadas\n", i);
break;
case 2: printf("En %d hubo mundial de ftbol\n", i);
break;
default: printf("En %d no pas nada\n", i);
}
}
2.2. Enunciados de la prctica

2.2.1. Suma de elementos de un vector
En este primer apartado, estudiaremos un bucle que calcula la suma de todos los
elementos de un vector. El vector se denomina vector y tiene 5 elementos de tipo
int (entero de 32 bits). Los algoritmos que realizan la suma de sus elementos, tanto
en C como en ensamblador, se pueden encontrar en los listados 2.8 y 2.9.
Listado 2.8: Suma de elementos de un vector (tipos4.c)
void main ( void ){

int i , suma ;
int vector [5]= {128 , 32 , 100 , -30 , 124};
for ( suma = i = 0; i <5; i ++ ){

suma += vector [ i ];
}
printf ( " La suma es %d \ n " , suma );
}
Listado 2.9: Suma de elementos de un vector (tipos4.s)

.data
var1 : .asciz " La suma es %d \ n "

var2 : .word 128, 32, 100, - 30, 124
.text
.global main
/* Salvamos registros */
/* Inicializamos variables y apuntamos r2 a var2 */

mov r0, # 5
mov r1, # 0
ldr r2, = var2
/* Bucle que hace la suma */

bucle : ldr r3, [ r2 ] , # 4
add r1, r1, r3
subs r0, r0, # 1
bne bucle
/* Imprimimos resultado */
ldr r0, = var1
bl printf
/* Recuperamos registros y salimos */

pop { r4, lr }
bx lr
Si analizamos el cdigo en ensamblador (listado 2.9), veremos que se recorre todo

el vector con el registro r0, realizndose la suma sobre el registro r1. A diferencia de
ejemplos anteriores decrementamos de 5 a 0, as nos ahorramos una comparacin,
ya que la instruccin subs detecta cuando hemos llegado al valor cero activando el
flag Z.
En r2 vamos recorriendo el vector elemento a elemento mediante un modo pos-
tindexado que apunta al siguiente elemento una vez leemos el actual con ldr. Una

vez calculada la suma en r1, la mostramos por pantalla mediante una llamada a
printf.
El cdigo del listado 2.9 est en el fichero tipos4.s. Compila y monta el progra-
ma con el as y el gcc. Ahora ejecuta el algoritmo con el gdb. Recuerda empezar con
start. Para ver su funcionamiento, podemos ejecutar un par de iteraciones con si
y ver cmo los valores de los registros van cambiando i r r0 r1 r2 r3 (de vez en
cuando ejecuta disas para saber por dnde vas). Si ejecutamos un par de iteraciones
con si veremos que el hecho de ejecutar instruccin a instruccin resulta poco til.
Para acelerar el proceso, podemos utilizar puntos de parada o breakpoints.
Otro problema que tenemos es que al ejecutar un paso de una instruccin exacta
si nos metemos dentro de la rutina printf, cosa que no nos interesa a no ser que
queramos descubrir las interioridades de la librera. Para evitar esto ejecutamos con
ni, que ejecutar bl printf de un paso sin meterse dentro de la rutina.
Para introducir un breakpoint hay varias maneras, siempre es buena idea in-
vestigar a fondo la ayuda que se nos brinda el propio depurador con help break.
Nosotros pondremos dos puntos de ruptura.
( gdb ) start
Temporary breakpoint 1 at 0x83cc
Starting program : / home / pi / tipos4
Temporary breakpoint 1, 0x000083cc in main ()

( gdb ) break bucle
Breakpoint 2 at 0x83dc
( gdb ) disas bucle
Dump of assembler code for function bucle :
0x000083dc <+0 >: ldr r3, [ r2 ] , # 4
0x000083e0 <+4 >: add r1, r1, r3
0x000083e4 <+8 >: subs r0, r0, # 1
0x000083e8 <+ 12 >: bne 0x83dc < bucle >
0x000083ec <+ 16 >: ldr r0, [ pc, # 12 ]
0x000083f0 <+ 20 >: bl 0x82f0 < printf >
0x000083f4 <+ 24 >: pop { r4, lr }
0x000083f8 <+ 28 >: bx lr
0x000083fc <+ 32 >: ; < UNDEFI..
0x00008400 <+ 36 >: andeq r0, r1, r4, lsr # 11
( gdb ) break * 0x83ec
Breakpoint 3 at 0x83ec
Ahora toca continuar la ejecucin del programa hasta el final o hasta llegar
a un punto de ruptura, y esto se hace con continue (de forma abreviada cont).
Tambin podemos mostrar la lista de puntos de ruptura, desactivar temporalmente

un breakpoint o simplemente borrarlo.

( gdb ) info breakpoints
Num Type Disp Enb Address What
2 breakpoint keep y 0x000083dc < bucle >
3 breakpoint keep y 0x000083ec < bucle + 16 >
( gdb ) disable 2
( gdb ) delete 3
( gdb ) i b
Num Type Disp Enb Address What
2 breakpoint keep n 0x000083dc < bucle >
Antes de acabar nuestra sesin con gdb depuramos la ltima iteracin del bucle,
y luego dos instrucciones ms para mostrar el texto que emite printf.
( gdb ) i r r0 r1
r0 0x1 1
r1 0xe6 230
( gdb ) disas
Dump of assembler code for function bucle :
= > 0x000083dc <+0 >: ldr r3, [ r2 ] , # 4
0x000083e0 <+4 >: add r1, r1, r3
0x000083e4 <+8 >: subs r0, r0, # 1
0x000083e8 <+ 12 >: bne 0x83dc < bucle >
0x000083ec <+ 16 >: ldr r0, [ pc, # 12 ]
0x000083f0 <+ 20 >: bl 0x82f0 < printf >
0x000083f4 <+ 24 >: pop { r4, lr }
0x000083f8 <+ 28 >: bx lr
( gdb ) ni 4
0x000083ec in bucle ()
( gdb ) i r r1 r3
r1 0x162 354
r3 0x7c 124
( gdb ) ni 2
La suma es 354
0x000083f4 in bucle ()
Ahora vamos a modificar un poco el programa. Copiamos tipos4.s en otro

fichero tipos5.s (con cp tipos4.s tipos5.s). Ahora modifica la lista de nmeros
del array, reemplazndola por esta otra.
var2 : .word 1600000000, - 100, 800000000, - 50, 200
Haz el ejercicio 2.5 y acbalo antes de seguir.

Ejercicio 2.5
Sabiendo que la suma de los 5 elementos del vector anterior es 2.400.000.050
completa el siguiente cuadro:
Traduce el nmero 2.400.000.050 a binario:
Interpreta el resultado como un entero de 32 bits y tradcelo a decimal, cunto

da?
Se puede representar el nmero entero 2.400.000.050 con 32 bits?
Si has hecho el ejercicio 2.5 puedes ahora comprobar que la suma de los valores
de este vector produce un overflow sobre un int. Por tanto, el programador debera
ir acumulando el resultado de la suma sobre un long long (64 bits), tal y como se
muestra en el siguiente listado.
void main ( void ){
int i ;
long long suma ;
int vector [5]= {1600000000 , -100 , 800000000 , -50 , 200};
for ( suma = i = 0; i <5; i ++ ){

suma += vector [ i ];
}
printf ( " La suma es %d \ n " , suma );
}
Listado 2.10: Suma de un vector de enteros largos (tipos6.s)

.data
var1 : .asciz " La suma es %lld \ n "

var2 : .word 1600000000, - 100, 800000000, - 50, 200
.text
.global main

main : push { r4, r5, r6, lr }
/* Inicializamos variables y apuntamos r4 a var2 */

mov r5, # 5
mov r2, # 0
mov r3, # 0
ldr r4, = var2
/* Bucle que hace la suma */

bucle : ldr r0, [ r4 ] , # 4
mov r1, r0, ASR # 31
adds r2, r2, r0
adc r3, r3, r1
subs r5, r5, # 1
bne bucle
/* Imprimimos resultado */
ldr r0, = var1
bl printf

pop { r4, r5, r6, lr }
bx lr
En el cdigo ensamblador la variable suma se almacena en los registros r3:r2.

Como el array almacenado en memoria es de 32 bits, lo que hacemos es cargar el va-
lor en cada iteracin en r0 y extender el signo mediante la instruccin mov r1, r0,
ASR #31 a los registros r1:r0. Por ltimo hacemos la suma r3:r2= r3:r2+r1:r0
mediante dos instrucciones de suma, en la primera adds sumamos los 32 bits inferio-
res almacenando tambin el posible acarreo (flag C), y en la segunda adc sumamos
los 32 bits superiores ms el acarreo anterior.
El nmero de 64 bits que le enviamos a la funcin printf debe estar en r3:r2,
debemos guardar en pila todos los registros por encima de r4 (incluyndolo) y en
el push debe haber un nmero par de elementos. Se explica ms adelante por qu.
Si tuvisemos un nmero impar, como es el caso, salvaremos el siguiente registro r6
aunque no lo necesitemos en nuestra funcin.
Ejercicio 2.6
Dada la definicin de matriz short mat[4][6]; cul es la frmula para acceder
al elemento mat[i][2]?

Listado 2.11: Matrices
matriz : .hword 0, 1, 2, 3, 4, 5
.hword 0x10, 0x11, 0x12, 0x13, 0x14, 0x15
.hword 0x20, 0x21, 0x22, 0x23, 0x24, 0x25
.hword 0x30, 0x31, 0x32, 0x33, 0x34, 0x35
suma : .hword 0
suma = 0;
for ( i = 0; i <4; i ++ ){
suma += mat [ i ][2];
}
Queremos hacer un programa que sume todos los elementos de la columna 2

de la matriz (listado 2.11). Completa tipos7.s para que implemente este cdigo,
utilizando dentro del bucle que realiza la suma la frmula del ejercicio 2.6. Para
comprobarlo, el resultado es 104 = 0x68.
Fjate en que en esta versin del cdigo que recorre los elementos de una columna,
para calcular la direccin de cada elemento aplicamos la ecuacin de la pgina 38.
A sto es a lo que llamamos acceso aleatorio a los elementos de la matriz.
Sin embargo, sabemos que hay una relacin entre los elementos de una fila y de
la siguiente, cuando el tamao de la columna es constante. Para hallar esta relacin
haz siguiente ejercicio.
Ejercicio 2.7
Calcula las frmulas de acceso a mat[i][2] y mat[i+1][2] y halla su diferencia
(resta las dos frmulas).
Una vez hallada esta relacin, que es un desplazamiento en memoria, ahora

sabes que se pueden recorrer todos los elementos de una columna sin ms que ir
sumando ese desplazamiento. Decimos entonces que hacemos un acceso secuencial
a los elementos de la matriz. Copia el fichero tipos7.s a tipos8.s e implementa
sobre este ltimo el acceso secuencial. El resultado tiene que ser el mismo que el
anterior (104 = 0x68).
Captulo 3
Subrutinas y paso de parmetros
Contenido
3.1 Lectura previa . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.1.1 La pila y las instrucciones ldm y stm . . . . . . . . . . . . 56
3.1.2 Convencin AAPCS . . . . . . . . . . . . . . . . . . . . . 58
3.2 Ejemplos de aplicacin . . . . . . . . . . . . . . . . . . . . 60
3.2.1 Funciones en ensamblador llamadas desde C . . . . . . . . 60
3.2.2 Funciones en ensamblador llamadas desde ensamblador . . 62
3.2.3 Funciones recursivas . . . . . . . . . . . . . . . . . . . . . 64
3.2.4 Funciones con muchos parmetros de entrada . . . . . . . 70
3.2.5 Pasos detallados de llamadas a funciones . . . . . . . . . . 75
3.3 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3.3.1 Mnimo de un vector . . . . . . . . . . . . . . . . . . . . . 76
3.3.2 Media aritmtica, macros y conteo de ciclos . . . . . . . . 78
3.3.3 Algoritmo de ordenacin . . . . . . . . . . . . . . . . . . . 80
Objetivos: En esta sesin experimentaremos con las subrutinas. Veremos en

qu consiste la convencin AAPCS y cmo aplicarla tanto para llamar a funciones
externas como para crear nuestras propias funciones. Escribiremos un programa en
C que llame a funciones escritas en ensamblador. Por ltimo explicaremos qu son
los registros de activacin y cmo aplicarlos para almacenar variables locales.
55
3.1. Lectura previa

3.1.1. La pila y las instrucciones ldm y stm
Se denomina pila de programa a aquella zona de memoria, organizada de forma
LIFO (Last In, First Out), que el programa emplea principalmente para el almace-
namiento temporal de datos. Esta pila, definida en memoria, es fundamental para
el funcionamiento de las rutinas1 , aspecto que se desarrollar en esta prctica.
El puntero de pila es r13 aunque por convencin nunca se emplea esa nome-
clatura, sino que lo llamamos sp (stack pointer o puntero de pila). Dicho registro
apunta siempre a la palabra de memoria que corresponde a la cima de la pila (ltima
palabra introducida en ella).
La pila tiene asociadas dos operaciones: push (meter un elemento en la pila) y
pop (sacar un elemento de la pila). En la operacin push primero decrementamos
en 4 (una palabra son 4 bytes) el registro sp y luego escribimos dicho elemento en
la posicin de memoria apuntada por sp. Decimos que la pila crece hacia abajo, ya
que cada vez que insertamos un dato el sp se decrementa en 4.
De esta forma, la instruccin push realmente implementa las dos siguientes ins-
trucciones:
Listado 3.1: Operacin push
sub sp, sp, # 4
str r0, [ sp ]
Para sacar elementos de la pila tenemos la operacin pop, que primero extrae el
elemento de la pila y luego incrementa el puntero (la pila decrece hacia arriba). Por
tanto, la instruccin pop es equivalente a:
Listado 3.2: Operacin pop
ldr r0, [ sp ]
add sp, sp, # 4
Un uso muy comn de la pila es salvaguardar una serie de registros, que quere-
mos usar para hacer las operaciones que necesitemos pero que al final tenemos que
restaurar a sus valores originales. En un procesador tpico escribiramos algo as:
1
En este texto usaremos el trmino rutina (o subrutina) como la implementacin a bajo nivel de
lo que en alto nivel se conoce como procedimientos y funciones. La diferencia entre procedimiento
y funcin, radica en que las funciones proporcionan un valor de retorno.

Captulo 3. Subrutinas y paso de parmetros 57
push r1
push r2
push r4
/* c digo que modifica los
registros r1, r2 y r4 */
pop r4
pop r2
pop r1
Observa que el orden de recuperacin de registros es inverso al de guardado.

Pues bien, en ARM lo tenemos mucho ms fcil. Gracias a las instrucciones de
carga/escritura mltiple podemos meter los registros en una lista, empleando una
nica instruccin.
push { r1, r2, r4 }
/* c digo que modifica los
registros r1, r2 y r4 */
pop { r1, r2, r4 }
En este caso el orden no es relevante, el procesador siempre usa el orden ascen-

dente para el push y el descendente para el pop, aunque nosotros por legibilidad
siempre escribiremos los registros en orden ascendente.
Realmente, para el procesador ARM las instrucciones push y pop no existen.
Sin embargo tenemos las instrucciones stm y ldm que son mucho ms potentes y el
ensamblador permite las pseudoinstrucciones push y pop que de forma transparente
traducir a stm y ldm.
Las instrucciones ldm y stm tienen la siguiente sintaxis.
ldm { modo_direc }{ cond } rn {!} , lista_reg
stm { modo_direc }{ cond } rn {!} , lista_reg
A continuacin explicamos cada uno de los argumentos de ldm/stm

1. modo_direc
ia: Incrementa direccin despus (increment after) de cada transferencia.
Es el modo por defecto en caso de omitirlo.
ib: Incrementa direccin antes (increment before) de cada transferencia.
da: Decrementa despus (decrement after) de cada transferencia.
db: Decrementa antes (decrement before) de cada transferencia.
2. cond. Es opcional, son las mismas condiciones de los flags que vimos en la
seccin 2.1.3 del captulo anterior (pgina 38), que permiten ejecutar o no
dicha instruccin.

3. rn. Es el registro base, el cual apunta a la direccin inicial de memoria donde se

har la transferencia. El registro ms comn es sp (r13), pero puede emplearse
cualquier otro.
4. !. Es un sufijo opcional. Si est presente, actualizamos rn con la direccin

calculada al final de la operacin.
5. lista_reg. Es una lista de uno o ms registros, que sern ledos o escritos en

memoria. La lista va encerrada entre llaves y separada por comas. Tambin
podemos usar un rango de registros. En este ejemplo se almacenan los registros
r3, r4, r5, r6, r10 y r12. Si inicialmente r1 contiene el valor 24, despus
de ejecutar la instruccin siguiente r3 se almacenar en la direccin 20, r4 en
16, r5 en 12, r6 en 8, r10 en 4 y r12 en 0.
stmdb r1 ! , { r3 - r6, r10, r12 }
Si tenemos en cuenta que push predecrementa, que pop postincrementa y que

ambas actualizan el registro base (que sera sp), la traduccin de las pseudoinstruc-
ciones push {r4, r6} y pop {r4, r6} seran respectivamente:
stmdb sp ! , { r4, r6 } /* push */
ldmia sp ! , { r4, r6 } /* pop */
Nosotros sin embargo emplearemos los nemnicos push/pop, mucho ms fciles

de recordar.
3.1.2. Convencin AAPCS

Podemos seguir nuestras propias reglas, pero si queremos interactuar con las
libreras del sistema, tanto para llamar a funciones como para crear nuestras propias
funciones y que stas sean invocadas desde un lenguaje de alto nivel, tenemos que
seguir una serie de pautas, lo que se denominamos AAPCS (Procedure Call Standard
for the ARM Architecture).
1. Podemos usar hasta cuatro registros (desde r0 hasta r3) para pasar parme-
tros y hasta dos (r0 y r1) para devolver el resultado.
2. No estamos obligados a usarlos todos, si por ejemplo la funcin slo usa dos
parmetros de tipo int con r0 y r1 nos basta. Lo mismo pasa con el resultado,
podemos no devolver nada (tipo void), devolver slo r0 (tipo int un puntero
a una estructura ms compleja), o bien devolver r1:r0 cuando necesitemos
enteros de 64 bits (tipo long long).

3. Los valores estn alineados a 32 bits (tamao de un registro), salvo en el caso

de que algn parmetro sea ms grande, en cuyo caso alinearemos a 64 bits.
Un ejemplo de esto lo hemos visto en el Ejercicio 2.5, donde necesitbamos
pasar dos parmetros: una cadena (puntero de 32 bits) y un entero tipo long
long. El puntero a cadena lo almacenbamos en r0 y el entero de 64 bits debe
empezar en un registro par (r1 no vale) para que est alineado a 64 bits, seran
los registros r2 y r3. En estos casos se emplea little endian, la parte menos
significativa sera r2 y la de mayor peso, por tanto, r3.
4. El resto de parmetros se pasan por pila. En la pila se aplican las mismas

reglas de alineamiento que en los registros. La unidad mnima son 32 bits,
por ejemplo si queremos pasar un char por valor, extendemos de byte a word
rellenando con ceros los 3 bytes ms significativos. Lo mismo ocurre con los
enteros de 64 bits, pero en el momento en que haya un slo parmetro de este
tipo, todos los dems se alinean a 64 bits.
5. Es muy importante preservar el resto de registros (de r4 en adelante incluyen-

do lr). La nica excepcin es el registro r12 que podemos cambiar a nuestro
antojo. Normalmente se emplea la pila para almacenarlos al comienzo de la
funcin y restaurarlos a la salida de sta. Puedes usar como registros tempo-
rales (no necesitan ser preservados) los registros desde r0 hasta r3 que no se
hayan empleado para pasar parmetros.
6. La pila debe estar alineada a 8 bytes, esto quiere decir que de usarla para pre-
servar registros, debemos reservar un nmero par de ellos. Si slo necesitamos
preservar un nmero impar de ellos, aadimos un registro ms a la lista dentro
del push, aunque no necesite ser preservado.
7. Aparte de para pasar parmetros y preservar registros, tambin podemos usar

la pila para almacenar variables locales, siempre y cuando cumplamos la regla
de alinear a 8 bytes y equilibremos la pila antes de salir de la funcin.
Cuando programamos en Bare Metal no es necesario seguir estas reglas. Es ms,

podemos escribir una funcin sin seguir la norma incluso si trabajamos bajo Linux,
pero no es recomendable ya que no podramos reusarlas para otros proyectos.
Lo mejor para entender estas reglas es con una serie de ejemplos de menor a
mayor complejidad que veremos a lo largo de este captulo.

60 3.2. Ejemplos de aplicacin
3.2. Ejemplos de aplicacin

3.2.1. Funciones en ensamblador llamadas desde C
En este primer ejemplo crearemos nuestras propias funciones generadoras de
nmeros aleatorios, a las que llamaremos myrand y mysrand (en sustitucin a las
rand y srand que ya existen en la librera).
Listado 3.3: Cdigo del programa subrut1.c
void main ( void ){

int i ;
mysrand (42);
for ( i = 0; i <5; i ++ ){
printf ( " %d \ n " , myrand ());
}
}
El programa principal lo hacemos en C, mientras que las funciones myrand y

mysrand las haremos en ensamblador. La implementacin es sencilla. Almacenamos
la semilla en la variable esttica seed. Podemos cambiar el valor de la semilla en
cualquier momento con la funcin mysrand, y recibir un nmero pseudoaleatorio
de 15 bits con la funcin myrand. En realidad myrand lo nico que hace es aplicar
una operacin sencilla en la semilla (multiplicacin y suma) y extraer 15 bits de
esta. El secreto del algoritmo reside en que se han elegido unas constantes para la
multiplicacin y la suma de tal forma que la variable seed pasar por todos los
valores de 32 bits en una secuencia que a simple vista parece aleatoria, pero que no
lo es (por eso se llama pseudoaleatoria):
static int seed ;
short myrand ( void ){

seed = seed *1103515245 + 12345;
return seed > >16 & 0 x7fff ;
}
void mysrand ( int x ){

seed = x ;
}

Veamos en qu se traducen estas funciones en ensamblador:

Listado 3.4: Cdigo del programa subrut1.s
.data
seed : .word 1
const1 : .word 1103515245
const2 : .word 12345
.text
.global myrand, mysrand
myrand : ldr r1, = seed @ leo puntero a semilla
ldr r0, [ r1 ] @ leo valor de semilla
ldr r2, [ r1, # 4 ] @ leo const1 en r2
mul r3, r0, r2 @ r3 = seed * 1103515245
ldr r0, [ r1, # 8 ] @ leo const2 en r0
add r0, r0, r3 @ r0 = r3 + 12345
str r0, [ r1 ] @ guardo en variable seed
/* Estas dos l neas devuelven " seed > > 16 & 0x7fff " .
Con un peque o truco evitamos el uso del AND */
LSL r0, # 1
LSR r0, # 17
bx lr
mysrand : ldr r1, = seed

str r0, [ r1 ]
bx lr
Antes de nada ensamblamos, compilamos/enlazamos y ejecutamos estos archivos

para comprobar su correcto funcionamiento:
pi@raspberrypi ~ $ as -o subrut1 . o subrut1 . s
pi@raspberrypi ~ $ gcc -o subrut1 subrut1 . c subrut1 . o
pi@raspberrypi ~ $ ./ subrut1
2929
28487
11805
6548
9708
pi@raspberrypi ~ $
A diferencia de ejemplos anteriores, en nuestro cdigo ensamblador no tenemos

ninguna funcin main porque sta la hemos implementado en C. Sin embargo apare-
cen dos etiquetas despus de la directiva .global, que son myrand y mysrand. Esto

es fundamental si queremos que nuestras funciones sean vistas desde el exterior, en

este caso desde el programa en C.
Empecemos con la funcin ms sencilla, mysrand. Consta de 3 instrucciones. En
la primera de ellas apuntamos con r1 a la direccin donde se encuentra la variable
seed. En la segunda pasamos el primer y nico parmetro de la funcin, r0, a
la posicin de memoria apuntada por r1, es decir, a la variable seed. Por ltimo
salimos de la funcin con la conocida instruccin bx lr. No hay ms, no tenemos
que devolver nada en r0 (la funcin devuelve el tipo void), ni tenemos que preservar
registros, ni crear variables locales.
La otra funcin es un poco ms compleja. Aparte de requerir ms clculos debe-
mos devolver un valor. Aprovechamos que las 3 variables estn almacenadas conse-
cutivamente (en realidad las dos ltimas son constantes) para no tener que cargar
3 veces la direccin de cada variable en un registro. Lo hacemos la primera vez con
ldr r1, =seed, y accedemos a las variables con direccionamiento a registro con
desplazamiento ( [r1], [r1, #4] y [r1, #8]). Como no hay parmetros de en-
trada empleamos los registros r0, r1, r2 y r3 como almacenamiento temporal,
hacemos nuestros clculos, escribimos el resultado en la variable seed y devolvemos
el resultado en el registro r0.
3.2.2. Funciones en ensamblador llamadas desde ensambla-

dor
Del ejemplo anterior vamos a pasar a ensamblador la nica parte que estaba
escrita en C, que era la funcin main:
.data
var1 : .asciz " %d \ n "

seed : .word 1
const1 : .word 1103515245
const2 : .word 12345
.text
.global main
main : push { r4, r5 }
/* Llamamos a mysrand con par metro 42 */

mov r0, # 42

bl mysrand
/* Inicializamos contador de bucle en r4 */

mov r4, # 5
/* Bucle que imprime 5 n meros aleatorios */

bucle : bl myrand @ leo n mero aleatorio
mov r1, r0 @ paso valor a r1
ldr r0, = var1 @ pongo cadena en r0
bl printf @ llamo a funci n printf
subs r4, r4, # 1 @ decremento contador
bne bucle @ salgo si llego a cero

pop { r4, r5 }
bx lr
myrand : ldr r1, = seed

ldr r0, [ r1 ]
ldr r2, [ r1, # 4 ]
mul r3, r0, r2
ldr r0, [ r1, # 8 ]
add r0, r0, r3
str r0, [ r1 ]
mov r0, r0, LSL # 1
mov r0, r0, LSR # 17
bx lr
mysrand : ldr r1, = seed

str r0, [ r1 ]
bx lr
Como vis ya no hace falta poner a .global las funciones myrand y mysrand,
puesto que son de uso interno. Sin embargo s lo hacemos con main, ya que ahora s
la implementamos en ensamblador. Al fin y al cabo main es otra funcin ms y por
tanto debe de seguir la normativa AAPCS.
Primero preservamos r4 y r5. En realidad r5 no se modifica y no hara falta
preservarla, pero lo hacemos para alinear a 8 la pila. Luego llamamos a mysrand
con el valor 42 como primer y nico parmetro. Inicializamos a 5 el contador del
bucle, que almacenamos en r4 y comenzamos el bucle. El bucle consiste en llamar
a myrand y pasar el resultado devuelto de esta funcin al segundo parmetro de la
funcin printf, llamar a printf, decrementar el contador y repetir el bucle hasta
que el contador llegue a cero. Una vez salimos del bucle recuperamos los registros

r4 y r5 y devolvemos el control al sistema: bx lr.
3.2.3. Funciones recursivas

El siguiente paso es implementar una funcin recursiva en ensamblador. Vamos
a escoger la secuencia de Fibonacci por su sencillez. Trataremos de imprimir los diez
primeros nmeros de la secuencia. Se trata de una sucesin de nmeros naturales en
las que los dos primeros elementos valen uno y los siguientes se calculan sumando
los dos elementos anteriores. Los diez primeros nmeros seran los siguientes.
1, 1, 2, 3, 5, 8, 13, 21, 34, 55...
Este es el cdigo en un lenguaje de alto nivel como C que imprime la anterior

secuencia.
Listado 3.6: Cdigo del programa subrut3.c
int fibonacci ( int n ){

if ( n < 2 )
return 1;
else
return fibonacci (n -1) + fibonacci (n -2);
}
void main ( void ){

int i ;
for ( i = 0; i <10; i ++ )
printf ( " %d \ n " , fibonacci ( i ));
}
Lo que vamos a explicar ahora es cmo crear variables locales dentro de una
funcin. Aunque en C no necesitemos variables locales para la funcin fibonacci,
s nos har falta en ensamblador, en concreto dos variables: una para acumular la
suma y otra para mantener el parmetro de entrada.
Para ello vamos a emplear la pila, que hasta ahora slo la dedicbamos para
salvaguardar los registros a partir de r4 en la funcin. La pila tendra un tercer uso
que no hemos visto todava. Sirve para que el llamador pase el resto de parmetros
en caso de que haya ms de 4. Los primeros 4 parmetros (dos en caso de parmetros
de 64 bits) se pasan por los registros desde r0 hasta r3. A partir de aqu si hay ms
parmetros stos se pasan por pila.
Las variables locales se alojan debajo del rea de salvaguarda de registros, para
ello hay que hacer espacio decrementando el puntero de pila una cierta cantidad de

bytes, e incrementando sp en esa misma cantidad justo antes de salir de la funcin.

En la figura 3.1 vemos el uso de la pila de una funcin genrica.
Figura 3.1: Uso de la pila en una funcin
Pues bien, en nuestro caso de la funcin fibonacci necesitamos 0 bytes para paso
de parmetros, 4 bytes para salvaguarda de registros (slo guardaremos lr) y 8
bytes para nuestras dos variables locales. Como la suma es de 12 bytes, que no
es mltiplo de 8, redondeamos a 16 aadiendo una tercera variable local que no
usaremos (tambin podramos haber salvaguardado un segundo registro). Nuestro
mapa particular lo podemos observar en la figura 3.2.
En teora podemos encargarnos nosotros mismos de hacer toda la aritmtica que
conlleva el uso de variables locales, pero en la prctica estamos ms expuestos a
cometer errores y nuestro cdigo es ms ilegible. Las 3 variables locales ocupan 12
bytes, a la primera accedemos con el direccionamiento [sp] y a la segunda con [sp,
#4] (la tercera no la usamos). El cdigo quedara como en el listado 3.7.

Figura 3.2: Uso de la pila en nuestra funcin
Listado 3.7: Funcin recursiva fibo (en subrut3.s)

fibo : push { lr } @ salvaguarda lr
sub sp, # 12 @ hago espacio para v. locales
cmp r0, # 2 @ if n < 2
movlo r0, # 1 @ return 1
blo fib1
sub r0, # 1 @ else

str r0, [ sp ] @ salvo n - 1 en [ sp ]
bl fibo @ fibonacci (n - 1 )
str r0, [ sp, # 4 ] @ salvo valor devuelto por fib. (n - 1 )
ldr r0, [ sp ] @ recupero de la pila n - 1
sub r0, # 1 @ calculo n - 2
ldr r1, [ sp, # 4 ] @ recupero salida de fib. (n - 1 )
add r0, r1 @ lo sumo a fib. (n - 1 )
fib1 : add sp, # 12 @ libero espacio de v. locales

pop { lr } @ recupero registros ( s lo lr )
bx lr @ salgo de la funci n
Siguiendo el orden de la pila, primero salvaguardamos lr y luego hacemos espacio

para 3 palabras con sub sp, #12 en el comienzo de la funcin. Al salir de la rutina
restauramos en orden inverso, primero restauramos los 12 bytes de las variables
locales y luego recuperamos lr.
Nuestra funcin tiene dos ramas, en una se comprueba que el parmetro sea
menor de 2, y si lo es devolvemos el valor 1 y salimos de la funcin. En la otra rama
invocamos nuestra propia funcin recursivamente dos veces, sumamos el resultado

y devolvemos la suma al salir de la funcin.

El truco para hacer el cdigo ms legible es nombrando las 3 variables locales y
la longitud mediante la directiva .equ (tambin nos valdra su alias .set). Partimos
del valor 0 de desplazamiento en la primera variable local y vamos encadenando.
A cada elemento le corresponde la longitud ms la posicin del anterior. As, si
necesitamos modificar alguna variable tan slo tendremos en cuenta la anterior y la
siguiente, no tenemos que modificar toda la estructura:
.equ local1, 0
.equ local2, 4 + local1
.equ length, 4 + local3
Con esta nueva filosofa el cdigo queda menos crptico, como vemos en el listado
3.8.
Listado 3.8: Funcin recursiva fibo (en subrut3.s)
sub sp, # length @ hago espacio para v.locales
cmp r0, # 2 @ if n < 2
blo fib1
sub r0, # 1 @ else

str r0, [ sp, # local1 ] @ salvo n - 1 en [ sp ]
str r0, [ sp, # local2 ] @ salvo salida de fib. (n - 1 )
ldr r0, [ sp, # local1 ] @ recupero de la pila n - 1
ldr r1, [ sp, # local2 ] @ recupero salida de fib (n - 1 )
fib1 : add sp, # length @ libero espacio de v.locales

pop { lr } @ recupero registros, s lo lr
Ya estamos en condiciones de mostrar el archivo completo en el listado 3.9.

.data
.text

.global main
/* Salvo registros */
/* Inicializo contador del bucle a 0 en r4 */

mov r4, # 0
/* Bucle que imprime los 10 primeros valores */

bucle : mov r0, r4 @ tomo contador como par metro
bl fibo @ llamo a la funci n
mov r1, r0 @ paso resultado a r1
ldr r0, = var1 @ pongo cadena en r0
bl printf @ llamo a funci n printf
add r4, r4, # 1 @ incremento contador de bucle
cmp r4, # 10 @ comparo si es menor de 10
bne bucle @ si llegamos a 10 salgo de bucle
/* Recupero registros y salgo de main */

pop { r4, lr }
bx lr
.equ local1, 0

cmp r0, # 2 @ if n < 2
blo fib1
sub r0, # 1 @ else


fib1 : add sp, # length @ libero espacio de v.locales

Lo nico que nos faltaba era la funcin main. La lista de .equ puede ir al co-
mienzo, pero por claridad la ponemos justo antes de la funcin a la que se va a
aplicar. La funcin main no tiene nada nuevo, salvo que incrementamos el contador
r4 en lugar de decrementarlo porque necesitamos dicho valor como parmetro para
llamar a la funcin fibo.
Para terminar con este ejemplo vamos a hacer una sencilla optimizacin. Observa
un momento la primera rama de la funcin. Si el parmetro es menor de dos tan slo
operamos con un registro, r0, tanto para comparar la entrada como para escribir el
valor de retorno. No se toca ningn registro ms, no hemos modificado lr porque
no hemos llamado a ninguna subrutina, tampoco hemos hecho uso de las variables
locales.
La optimizacin consiste (ver listado 3.10) en procesar la primera rama antes
de las operaciones con la pila, de esta forma nos ahorramos algunos ciclos de reloj.
Es un buen ejemplo para comprobar lo flexibles que pueden ser las funciones: hay
funciones en las que podemos evitar tratar con la pila como en el listado 3.5, otras
en las que no tenemos ms remedio, y un ltimo caso en que podemos tener una
mezcla de ambas alternativas.
Listado 3.10: Parte del cdigo del programa subrut4.s
fibo : cmp r0, # 2 @ if n < 2
bxlo lr @ salgo de la funci n
push { lr } @ salvaguarda lr
sub r0, # 1 @ r0 = n - 1
add sp, # length @ libero espacio de v.locales


3.2.4. Funciones con muchos parmetros de entrada

Lo ltimo que nos falta por ver es cmo acceder a los parmetros de una funcin
por pila, para lo cual necesitamos una funcin de al menos cinco parmetros. Lo
ms sencillo que se nos ocurre es un algoritmo que evalue cualquier polinomio de
grado 3 en el dominio de los enteros.
f (x) = ax3 + bx2 + cx + d (3.1)

Nuestra funcin tendra 5 entradas, una para cada coeficiente, ms el valor de la
x que sera el quinto parmetro que pasamos por pila. Como siempre, comenzamos
escribiendo el cdigo en C:
Listado 3.11: Evaluador de polinomios subrut5.c
int poly3 ( int a , int b , int c , int d , int x ){
return a * x * x * x + b * x * x + c * x + d ;
}
void main ( void ){

printf ( " %d \ n %d \ n %d \ n " ,
poly3 (1 , 2 , 3 , 4 , 5) ,
poly3 (1 , -1 , 1 , -1 , 8) ,
poly3 (2 , 0 , 0 , 0 , 8));
}
Cuya salida es la siguiente.

194
455
1024
El cdigo completo en ensamblador se muestra en el listado 3.12.

Listado 3.12: Evaluador de polinomios subrut5.s
.data
.text
.global main
/* Introduzco los 4 primeros par metros v a registros */

mov r0, # 1

mov r1, # 2
mov r2, # 3
mov r3, # 4
/* Introduzco el 5o par metro por pila */

mov r4, # 5
push { r4 }
/* Llamada a funci n poly3 ( 1, 2, 3, 4, 5 ) */

bl poly3
/* Equilibro la pila ( debido al 5o par metro ) */

add sp, # 4
/* Paso resultado de la funci n a r1, cadena a

imprimir a r0 y llamo a la funci n */
mov r1, r0
ldr r0, = var1
bl printf
/* Segunda llamada, esta vez poly3 ( 1, - 1, 1, - 1, 8 ) */

mov r0, # 1
mov r1, # - 1
mov r2, # 1
mov r3, # - 1
mov r4, # 8
push { r4 }
bl poly3
add sp, # 4
/* Imprimo resultado de segunda llamada */

mov r1, r0
ldr r0, = var1
bl printf
/* Llamo e imprimo poly3 ( 2, 0, 0, 0, 8 ) */

mov r0, # 2
mov r1, # 0
mov r2, # 0
mov r3, # 0
mov r4, # 8
push { r4 }
bl poly3

add sp, # 4
mov r1, r0
ldr r0, = var1
bl printf
/* Recupero registros y salgo de main */

pop { r4, lr }
bx lr
.equ param5, 4*1 /* r4 */
poly3 : push { r4 } @ salvaguarda r4

ldr r4, [ sp, # param5 ] @ leo r4 de pila
smlabb r3, r2, r4, r3 @ r3 = c * x + d
smulbb r2, r4, r4 @ r2 = x * x
smlabb r3, r1, r2, r3 @ r3 = b *( x * x ) + ( c * x + d )
smulbb r2, r2, r4 @ r2 = x *( x * x )
smlabb r0, r0, r2, r3 @ r0 = a * x * x * x + b * x * x + c * x + d
pop { r4 } @ recupero r4
Vemos como hemos usado un .equ para facilitar la legibilidad del cdigo, as
accedemos al ndice del quinto parmetro sin tener que hacer clculos. El mapa de
la pila quedara as.
Figura 3.3: Mapa de pila de funcin poly3
Se pueden combinar los .equ de variables locales con los de parmetros por pila,
por ejemplo si tuvisemos una funcin hipottica con 6 parmetros (dos de ellos
pasados por pila), 3 variables locales y salvaguarda de 3 registros, lo haramos de la
siguiente forma.
.equ local1, 0


.equ param5, 4 * 3 + length /* r4,r5,lr */
.equ param6, 4 + param5
func : push { r4, r5, lr }

...
Y ste sera el mapa de pila de nuestra hipottica funcin.
Figura 3.4: Mapa de funcin hipottica
Los nmeros que hemos puesto a la izquierda de cada elemento se corresponden

con las constantes que calcula el preprocesador para el desplazamiento respecto al
puntero de pila. De no haber empleado la lista de .equ tendramos que calcular
nosotros mismos estos desplazamientos, y lo que es peor, el cdigo perdera legi-
bilidad. No es lo mismo poner ldr r4, [sp, #param5], que por ejemplo ldr r4,
[sp, #24], ya que habra que revisar a qu corresponde el desplazamiento #24 o
indicarlo como comentario.
Por norma general en la arquitectura ARM se emplean muy poco las variables
locales, ya que operar con stas implica guardarlas y restaurarlas de memoria, para
lo que se requieren instrucciones adicionales (recuerda que el procesador no realiza
operaciones aritmticas directamente en memoria). En lugar de variables locales se
suelen emplear directamente los registros que han sido salvaguardados previamente
con la instruccin push, esto nos da juego para trabajar con hasta 10 registros (desde
r4 hasta r12, incluyendo lr) como almacn temporal para nuestras operaciones.

Veamos ahora nuestra funcin poly3. Hemos salvaguardado r4 porque necesita-

mos un almacn temporal donde operar con el quinto parmetro que leeremos por
pila. En esta funcin la pila est alineada a 8 bytes porque usamos 4 bytes en el
quinto parmetro ms los 4 bytes de salvaguardar r4, en total 8 bytes.
Todas los clculos se condensan en 5 lneas donde se alternan las instrucciones
smlaxy y smulxy. Son instrucciones que multiplican/acumulan y multiplican res-
pectivamente nmeros enteros. El comportamiento exacto de cada instruccin viene
detallado en el datasheet[6] del procesador. 2
smlabb r3, r2, r4, r3 @ r3 = d+c*x
smulbb r2, r4, r4 @ r2 = x^2
smlabb r3, r1, r2, r3 @ r3 = d+c*x+b*x^2
smulbb r2, r2, r4 @ r2 = x^3
smlabb r0, r0, r2, r3 @ r0 = d+c*x+b*x^2+a*x^3
Como podis observar, las instrucciones ARM son muy potentes, permiten im-
plementar en 5 instrucciones lo que en C nos habra costado 6 multiplicaciones y 4
sumas. Ntese cmo reusamos los registros r2 y r3: al principio son parmetros de
entrada, pero luego los empleamos como registros temporales a medida que no los
necesitamos ms.
Despus de esto acaba la funcin con las habituales pop r4 y bx lr. Ya hemos
terminado la funcin poly3, que ha quedado bastante pequea en tamao. Todo
lo contrario que la funcin main. Sin embargo, la funcin main es larga por varias
razones: hacemos 3 llamadas a poly3, debemos introducir muchas constantes, al-
gunas de ellas en pila, y debemos imprimir los resultados y hacer el equilibrado de
pila. Este equilibrado de pila consiste en incrementar sp despus de la llamada a la
funcin para desalojar los parmetros que previamente habamos introducido en la
misma. Como en nuestro ejemplo pasamos por pila un nico parmetro de 4 bytes,
lo que hacemos es incrementar sp en 4 tras cada llamada a poly3.
Un detalle muy importante que no podemos observar en nuestro ejemplo es que
los parmetros que pasamos por pila se pasan en orden inverso desde el ltimo al
quinto. Esto es as porque la pila crece hacia abajo. Es ms, es aconsejable reusar
los registros r0-r3 para introducir los parmetros por pila. Si tuvisemos que pasar
6 parmetros (constantes del 1 al 6) lo haramos as:
mov r0, # 6
push { r0 }
mov r0, # 5
push { r0 }
mov r0, # 1
mov r1, # 2
2
Tambin es fcil encontrar la especificacin de una instruccin buscando su nemnico en
Google, ya que suele aparecer la ayuda oficial de ARM en el primer resultado de la bsqueda

mov r2, # 3
mov r3, # 4
Como vis no hay una forma clara y legible de introducir los parmetros de una
funcin. Hay que Tener cuidado con los push mltiples, ya que no importa el orden en
que especifiques los registros, el procesador siempre introduce en pila el registro ms
alto y va hacia atrs hasta llegar al primero. Aprovechando esto podemos mejorar
el ejemplo anterior:
mov r0, # 5
mov r1, # 6
push { r0, r1 }
mov r0, # 1
mov r1, # 2
mov r2, # 3
mov r3, # 4
Por ltimo vamos a mejorar un poco la velocidad de la funcin poly3 de esta

forma:
Listado 3.13: Parte de subrut6.s
poly3 : sub sp, # 4
ldr r12, [ sp, # param5 ]
smlabb r3, r2, r12, r3
smulbb r2, r12, r12
smulbb r2, r2, r12
add sp, # 4
bx lr
En qu consiste la mejora? Pues que hemos usado el registro basura r12, que es
el nico que podemos emplear sin salvaguardarlo previamente en la lista del push.
Esto nos quitara el push y el pop, aunque en este ejemplo lo hemos reemplazado por
instrucciones sub y add. La razn es que debemos mantener el puntero de pila en
un mltiplo de 8. No obstante las instrucciones que no acceden a memoria siempre
son ms rpidas que las que lo hacen, as que hemos ganado velocidad.
3.2.5. Pasos detallados de llamadas a funciones

Como ya hemos visto todos los casos posibles, hacemos un resumen de todo en
una serie de puntos desde que pasamos los parmetros en el llamador hasta que
restauramos la pila desde el llamador, pasando por la llamada a la funcin y la
ejecucin de la misma.

76 3.3. Ejercicios
1. Usando los registros r0-r3 como almacn temporal, el llamador pasa por pila
los parmetros quinto, sexto, etc... hasta el ltimo. Cuidado con el orden,
especialmente si se emplea un push mltiple. Este paso es opcional y slo
necesario si nuestra funcin tiene ms de 4 parmetros.
2. El llamador escribe los primeros 4 parmetros en r0-r3. Este paso es opcional,

ya que nos lo podemos saltar si nuestra funcin no tiene parmetros.
3. El llamador invoca a la funcin con bl. Este paso es obligatorio.
4. Ya dentro de la funcin, lo primero que hace esta es salvaguardar los registros

desde r4 que se empleen ms adelante como registros temporales. En caso de
no necesitar ningn registro temporal nos podemos saltar este paso.
5. Decrementar la pila para hacer hueco a las variables locales. La suma de bytes
entre paso de parmetros por pila, salvaguarda y variables locales debe ser
mltiplo de 8, rellenar aqu hasta completar. Como este paso es opcional, en
caso de no hacerlo aqu el alineamiento se debe hacer en el paso 4.
6. La funcin realiza las operaciones que necesite para completar su objetivo,

accediendo a parmetros y variables locales mediante constantes .equ para
aportar mayor claridad al cdigo. Se devuelve el valor resultado en r0 ( en
r1:r0 si es doble palabra).
7. Incrementar la pila para revertir el alojamiento de variables locales.
8. Recuperar con pop la lista de registros salvaguardados.
9. Retornar la funcin con bx lr volviendo al cdigo llamador, exactamente a la

instruccin que hay tras el bl.
10. El llamador equilibra la pila en caso de haber pasado parmetros por ella.
3.3. Ejercicios
3.3.1. Mnimo de un vector
Dado un vector de enteros y su longitud, escribe una funcin en ensamblador
que recorra todos los elementos del vector y nos devuelva el valor mnimo. Para
comprobar su funcionamiento, haz .global la funcin y tras ensamblarla, enlzala
con este programa en C.

# include < stdio.h >
int vect []= { 8, 10, - 3, 4, - 5, 50, 2, 3 };
void main ( void ){

printf ( " %d \ n " , minimo ( vect, 8 ));
}
Hay muchas formas de calcular el mnimo de una lista de elementos, la ms

sencilla es comparar todos los elemento con una variable, la cual actualizamos slo
si el elemento es menor que la variable. Usa el siguiente cuadro para escribir la
versin en ensamblador.
int minimo(int* v, int len){

int i, min;
min= v[0];
for ( i= 1; i<len; i++ )
if( v[i]<min )
min= v[i];
return min;
}

78 3.3. Ejercicios
3.3.2. Media aritmtica, macros y conteo de ciclos

Media aritmtica
Escribe una funcin en ensamblador que calcule la media aritmtica (truncada
porque trabajamos con enteros) de dos nmeros. Escribe tambin la funcin main
con cinco llamadas a media con distintos parmetros.
Una vez hecho esto, supn que cada instruccin tarda un ciclo de reloj en eje-
cutarse. Cuenta manualmente el nmero de ciclos que tarda la ejecucin completa
desde la primera instruccin de main hasta la ltima bx lr, incluyendo sta. En
caso de una llamada a subrutina cuenta todas las instrucciones que se ejecutan me-
tindote en la subrutina. La nica excepcin es bl printf, que debes contar como
un nico ciclo.
Haz lo mismo pero usando la herramienta gdb para comprobar el resultado ante-
rior. Recuerda no meterte dentro de los printf con ni. En las llamadas a la funcin
media usa si.
Macros
Hay una forma de acelerar las funciones, aunque slo es prctica para funciones
pequeas que se utilicen mucho. Se trata de escribir el contenido de la funcin en
lugar de llamar a la misma, y para evitar repetir siempre el mismo cdigo utilizamos
la directiva .macro. Con este truco nos ahorramos al menos la ejecucin de las
instrucciones bl funcion y bx lr. El inconveniente es que el tamao del ejecutable
ser mayor.
En el listado 3.14 vemos un ejemplo que usa la funcin abs, pero que con un
simple cambio empleamos la macro del mismo nombre.
Listado 3.14: Parte de subrut8.s
.macro abs
tst r0, r0

negmi r0, r0
.endm
.data
.text
.global main
/* Primera llamada abs ( 1 ) */

mov r0, # 1
bl abs
/* Imprimo primera llamada */

mov r1, r0
ldr r0, = var1
bl printf
/* Segunda llamada abs ( - 2 ) e imprimo */

mov r0, # - 2
bl abs
mov r1, r0
ldr r0, = var1
bl printf
/* Tercera llamada abs ( 3 ) e imprimo */

mov r0, # 3
bl abs
mov r1, r0
ldr r0, = var1
bl printf
/* Cuarta llamada abs ( - 4 ) e imprimo */

mov r0, # - 4
bl abs
mov r1, r0
ldr r0, = var1
bl printf
pop { r4, lr }
bx lr

80 3.3. Ejercicios
abs : tst r0, r0 @ comprueba el flag de signo

negmi r0, r0 @ si es negativo, negamos de nuevo
bx lr
Borra el bl antes del abs para probar la versin con macros. Dentro de gdb la
secuencia de comandos para contar los pasos saltndose el bl printf junto con la
cuenta es la siguiente.
start -> si 6 -> ni -> si 5 -> ni ->
-> si 5 -> ni -> si 5 -> ni -> si 2
6 + 1 + (5 + 1) 3 + 2 = 27
Reescribe el ejercicio anterior de la media aritmtica empleando macros en vez
de funciones.
Conteo de ciclos
Completa la siguiente tabla usando los dos tipos de conteo que acabamos de
explicar.
Ciclos contados Ciclos contados Ciclos manualmente Ciclos, con gdb

manualmente con gdb empleando macros y macros
media
abs 27
Este conteo de ciclos es ilustrativo. En un procesador real slo las instrucciones

simples tardan un ciclo de reloj, siempre y cuando el resultado de la operacin
no se utilice en la instruccin posterior, en cuyo caso la duracin es de dos ciclos.
Despus hay instrucciones complejas como las multiplicaciones, que necesitan 3 ciclos
(ms si hay que aadir la penalizacin anterior). Por ltimo estn los casos ms
complejos. Por un lado tenemos los saltos condicionales, donde el procesador hace
una prediccin de salto dentro de las 2 posibilidades que hay, si se produce un fallo
en la prediccin se penalizan ciclos. Por otro lado estn los accesos a memoria, que
tampoco tienen una temporizacin constante porque est la cach por medio. Si se
produce un fallo de cach hay que aadir la penalizacin correspondiente.
3.3.3. Algoritmo de ordenacin

Escoge un algoritmo de ordenacin de entre los 4 siguientes e implemntalo en
ensamblador:

Burbuja.
Seleccin.
Insercin.
Quicksort.
Como ejemplo mostramos el cdigo en C del algoritmo de la burbuja.

Listado 3.15: Parte de subrut9.c
int vect []= {8 , 10 , -3 , 4 , -5 , 50 , 2 , 3};
void ordena ( int * v , int len ){

int i , j , aux ;
for ( i = 1; i < len ; i ++ )

for ( j = 0; j < len - i ; j ++ )
if ( v [ j ] > v [ j +1] )
aux = v [ j ] ,
v [ j ]= v [ j +1] ,
v [ j +1]= aux ;
}
void main ( void ){

int i ;
ordena ( vect , 8);

for ( i = 0; i <8; i ++ )
printf ( " %d \ n " , vect [ i ]);
}
La lista de algoritmos est ordenada por dificultad, por lo que el algoritmo

Quicksort es con diferencia el ms difcil de implementar. Recomendamos dejarlo
para el final en caso de que el alumno decida realizar los 4 algoritmos en ensamblador.
Captulo 4
E/S a bajo nivel
Contenido
4.1 Lectura previa . . . . . . . . . . . . . . . . . . . . . . . . . 84
4.1.1 Libreras y Kernel, las dos capas que queremos saltarnos . 84
4.1.2 Ejecutar cdigo en Bare Metal . . . . . . . . . . . . . . . 86
4.2 Acceso a perifricos . . . . . . . . . . . . . . . . . . . . . . 88
4.2.1 GPIO (General-Purpose Input/Output) . . . . . . . . . . 89
4.2.2 Temporizador del sistema . . . . . . . . . . . . . . . . . . 95
4.3 Ejemplos de programas Bare Metal . . . . . . . . . . . . 96
4.3.1 LED parpadeante con bucle de retardo . . . . . . . . . . . 96
4.3.2 LED parpadeante con temporizador . . . . . . . . . . . . 99
4.3.3 Sonido con temporizador . . . . . . . . . . . . . . . . . . . 99
4.4 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
4.4.1 Cadencia variable con bucle de retardo . . . . . . . . . . . 101
4.4.2 Cadencia variable con temporizador . . . . . . . . . . . . 101
4.4.3 Escala musical . . . . . . . . . . . . . . . . . . . . . . . . 101
Objetivos: Hasta ahora hemos programado en ensamblador sobre la capa que

nos ofrece el sistema operativo. Nosotros llamamos a una funcin y sta hace todo
lo dems: le dice al sistema operativo lo que tiene que hacer con tal perifrico y
el sistema operativo (en concreto el kernel) le enva las rdenes directamente al
perifrico, al espacio de memoria donde est mapeado el mismo.
Lo que vamos a hacer en este captulo es comunicarnos directamente con los
perifricos, para lo cual debemos prescindir totalmente del sistema operativo. Este
modo de acceder directamente al hardware de la mquina se denomina Bare Metal,
83
que traducido viene a ser algo como Metal desnudo, haciendo referencia a que
estamos ante la mquina tal y cmo es, sin ninguna capa de abstraccin de por
medio.
Veremos ejemplos de acceso directo a perifricos, en concreto al LED de la pla-
ca auxiliar (ver apndice B) y a los temporizadores, que son bastante sencillos de
manejar.
4.1. Lectura previa

4.1.1. Libreras y Kernel, las dos capas que queremos saltar-
nos
Anteriormente hemos utilizado funciones especficas para comunicarnos con los
perifricos. Si por ejemplo necesitamos escribir en pantalla, llamamos a la funcin
printf. Pues bien, entre la llamada a la funcin y lo que vemos en pantalla hay 2
capas software de por medio.
Una primera capa se encuentra en la librera runtime que acompaa al ejecutable,
la cual incluye slamente el fragmento de cdigo de la funcin que necesitemos, en
este caso en printf. El resto de funciones de la librera (stdio), si no las invocamos
no aparecen en el ejecutable. El enlazador se encarga de todo esto, tanto de ubicar
las funciones que llamemos desde ensamblador, como de poner la direccin numrica
correcta que corresponda en la instruccin bl printf.
Este fragmento de cdigo perteneciente a la primera capa s que podemos depu-
rarlo mediante gdb. Lo que hace es, a parte del formateo que realiza la propia funcin,
trasladar al sistema operativo una determinada cadena para que ste lo muestre por
pantalla. Es una especie de traductor intermedio que nos facilita las cosas. Nosotros
desde ensamblador tambin podemos hacer llamadas al sistema directamente como
veremos posteriormente.
La segunda capa va desde que hacemos la llamada al sistema (System Call o
Syscall) hasta que se produce la transferencia de datos al perifrico, retornando
desde la llamada al sistema y volviendo a la primera capa, que a su vez retornar el
control a la llamada a librera que hicimos en nuestro programa inicialmente.
En esta segunda capa se ejecuta cdigo del kernel, el cual no podemos depurar.
Adems el procesador entra en un modo privilegiado, ya que en modo usuario (el
que se ejecuta en nuestro programa ensamblador y dentro de la librera) no tene-
mos privilegios suficientes como para acceder a la zona de memoria que mapea los
perifricos.
La funcin printf es una funcin de la librera del lenguaje C. Como vemos en
la figura, esta funcin internamente llama a la System Call (rutina del Kernel del
SO) write que es la que se ejecuta en modo supervisor y termina accediendo a los

Captulo 4. E/S a bajo nivel 85
perifricos (en este caso al terminal o pantalla donde aparece el mensaje). En la

figura 4.1 podemos ver el cdigo llamador junto con las dos capas.
Figura 4.1: Funcionamiento de una llamada a printf
Ahora veremos un ejemplo en el cual nos saltamos la capa intermedia para comu-
nicarnos directamente con el kernel va llamada al sistema. En este ejemplo vamos
a escribir una simple cadena por pantalla, en concreto "Hola Mundo!".
Listado 4.1: esbn1.s
.data
cadena : .asciz " Hola Mundo !\ n "

cadenafin :
.text
.global main
main : push { r7, lr } /* preservamos reg. */

mov r0, # 1 /* salida est ndar */
ldr r1, = cadena /* cadena a enviar */
mov r2, # cadenafin - cadena /* longitud */
mov r7, # 4 /* seleccionamos la */
swi #0 /* llamada a sistema write */
mov r0, # 0 /* devolvemos ok */
pop { r7, lr } /* recuperamos reg. */
bx lr /* salimos de main */

La instruccin que ejecuta la llamada al sistema es swi #0, siempre tendr cero
como valor inmediato. El cdigo numrico de la llamada y el nmero de parmetros
podemos buscarlo en cualquier manual de Linux, buscando Linux system call table
en Google. En nuestro caso la llamada write se corresponde con el cdigo 4 y acepta
tres parmetros: manejador de fichero, direccin de los datos a escribir (nuestra
cadena) y longitud de los datos. En nuestro ejemplo, el manejador de fichero es el
1, que est conectado con la salida estndar o lo que es lo mismo, con la pantalla.
En general se tiende a usar una lista reducida de posibles llamadas a sistema, y
que stas sean lo ms polivalentes posibles. En este caso vemos que no existe una
funcin especfica para escribir en pantalla. Lo que hacemos es escribir bytes en un
fichero, pero usando un manejador especial conocido como salida estndar, con lo
cual todo lo que escribamos a este fichero especial aparecer por pantalla.
Pero el propsito de este captulo no es saltarnos una capa para comunicarnos
directamente con el sistema operativo. Lo que queremos es saltarnos las dos capas
y enviarle rdenes directamente a los perifricos. Para esto tenemos prescindir del
sistema operativo, o lo que es lo mismo, hacer nosotros de sistema operativo para
realizar las tareas que queramos.
Este modo de trabajar (como hemos adelantado) se denomina Bare Metal, por-
que accedemos a las entraas del hardware. En l podemos hacer desde cosas muy
sencillas como encender un LED hasta programar desde cero nuestro propio sistema
operativo.
4.1.2. Ejecutar cdigo en Bare Metal

El ciclo de ensamblado y enlazado es distinto en un programa Bare Metal. Hasta
ahora hemos creado ejecutables, que tienen una estructura ms compleja, con cabe-
cera y distintas secciones en formato ELF [8]. Toda esta informacin le viene muy
bien al sistema operativo, pero en un entorno Bare Metal no disponemos de l. Lo
que se carga en kernel.img es un binario sencillo, sin cabecera, que contiene direc-
tamente el cdigo mquina de nuestro programa y que se cargar en la direccin de
RAM 0x8000.
Lo que para un ejecutable hacamos con esta secuencia.
as -o ejemplo.o ejemplo.s
gcc -o ejemplo ejemplo.o
En caso de un programa Bare Metal tenemos que cambiarla por esta otra.
as -o ejemplo.o ejemplo.s
ld -e 0 - Ttext = 0x8000 -o ejemplo.elf ejemplo.o
objcopy ejemplo.elf -O binary kernel.img

Otra caracterstica de Bare Metal es que slo tenemos una seccin de cdigo
(la seccin .text), y no estamos obligados a crear la funcin main. Al no ejecutar
ninguna funcin no tenemos la posibilidad de salir del programa con bx lr, al fin y
al cabo no hay ningn sistema operativo detrs al que regresar. Nuestro programa
debe trabajar en bucle cerrado. En caso de tener una tarea simple que queramos
terminar, es preferible dejar el sistema colgado con un bucle infinito como ltima
instruccin.
El proceso de arranque de la Raspberry Pi es el siguiente:
Cuando la encendemos, el ncleo ARM est desactivado. Lo primero que se

activa es el ncleo GPU, que es un procesador totalmente distinto e indepen-
diente al ARM. En este momento la SDRAM est desactivada.
El procesador GPU empieza a ejecutar la primera etapa del bootloader (son

3 etapas), que est almacenada en ROM dentro del mismo chip que compar-
ten ARM y GPU. Esta primera etapa accede a la tarjeta SD y lee el fichero
bootcode.bin en cach L2 y lo ejecuta, siendo el cdigo de bootcode.bin la
segunda etapa del bootloader.
En la segunda etapa se activa la SDRAM y se carga la tercera parte del bootloa-

der, cuyo cdigo est repartido entre loader.bin (opcional) y start.elf.
En tercera y ltima etapa del bootloader se accede opcionalmente a dos ar-

chivos ASCII de configuracin llamados config.txt y cmdline.txt. Lo ms
relevante de esta etapa es que cargamos en RAM (en concreto en la direccin
0x8000) el archivo kernel.img con cdigo ARM, para luego ejecutarlo y aca-
bar con el bootloader, pasando el control desde la GPU hacia la CPU. Este
ltimo archivo es el que nos interesa modificar para nuestros propsitos, ya
que es lo primero que la CPU ejecuta y lo hace en modo privilegiado, es decir,
con acceso total al hardware.
De todos estos archivos los obligatorios son bootcode.bin, start.elf y kernel.img.

Los dos primeros los bajamos del repositorio oficial https://github.com/raspberrypi
y el tercero kernel.img es el que nosotros vamos a generar. Estos tres archivos de-
ben estar en el directorio raz de la primera particin de la tarjeta SD, la cual debe
estar formateada en FAT32.
El proceso completo que debemos repetir cada vez que desarrollemos un progra-
ma nuevo en Bare Metal es el siguiente:
Apagamos la Raspberry.
Extraemos la tarjeta SD.

88 4.2. Acceso a perifricos
Introducimos la SD en el lector de nuestro ordenador de desarrollo.
Montamos la unidad y copiamos (sobreescribimos) el kernel.img que acabamos

de desarrollar.
Desmontamos y extraemos la SD.
Insertamos de nuevo la SD en la Raspberry y la encendemos.
Es un proceso sencillo para las prcticas que vamos a hacer, pero para proyectos
ms largos se vuelve bastante tedioso. Hay varias alternativas que agilizan el ciclo
de trabajo, donde no es necesario extraer la SD y por tanto podemos actualizar el
kernel.img en cuestin de segundos. Estas alternativas son:
Cable JTAG con software Openocd: http://openocd.sourceforge.net
Cable USB-serie desde el ordenador de desarrollo hacia la Raspberry, requiere

tener instaladas las herramientas de compilacin cruzada en el ordenador de
desarrollo.
Cable serie-serie que comunica dos Raspberries, una orientada a desarrollo y la

otra para ejecutar los programas en Bare Metal. No es imprescindible trabajar
directamente con la Raspberry de desarrollo, podemos acceder va ssh con
nuestro ordenador habitual, sin necesidad de tener instaladas las herramientas
de compilacin en el mismo.
Las dos ltimas opciones estn detalladas en el apndice C. Bsicamente se trata

de meter en el kernel.img de la SD un programa especial (llamado bootloader) que
lee continuamente del puerto serie y en el momento en que recibe un archivo del
tipo kernel.img, lo carga en RAM y lo ejecuta.
4.2. Acceso a perifricos

Los perifricos se controlan leyendo y escribiendo datos a los registros asociados
o puertos de E/S. No confundir estos registros con los registros de la CPU. Un
puerto asociado a un perifrico es un ente, normalmente del mismo tamao que el
ancho del bus de datos, que sirve para configurar diferentes aspectos del mismo. No
se trata de RAM, por lo que no se garantiza que al leer de un puerto obtengamos
el ltimo valor que escribimos. Es ms, incluso hay puertos que slo admiten ser
ledos y otros que slo admiten escrituras. La funcionalidad de los puertos tambin
es muy variable, incluso dentro de un mismo puerto los diferentes bits del mismo
tienen distinto comportamiento.

Como cada perifrico se controla de una forma diferente, no hay ms remedio

que leerse el datasheet del mismo si queremos trabajar con l. De ahora en adelante
usaremos una placa auxiliar, descrita en el apndice B, y que conectaremos a la fila
inferior del conector GPIO segn la figura 4.2. En esta seccin explicaremos cmo
encender un LED de esta placa auxiliar.
Figura 4.2: Colocacin de la placa auxiliar
4.2.1. GPIO (General-Purpose Input/Output)

El GPIO es un conjunto de seales mediante las cuales la CPU se comunica con
distintas partes de la Rasberry tanto internamente (audio analgico, tarjeta SD o
LEDs internos) como externamente a travs de los conectores P1 y P5. Como la
mayor parte de las seales se encuentran en el conector P1 (ver figura 4.3), normal-
mente este conector se denomina GPIO. Nosotros no vamos a trabajar con seales
GPIO que no pertenezcan a dicho conector, por lo que no habr confusiones.
El GPIO contiene en total 54 seales, de las cuales 17 estn disponibles a travs
del conector GPIO (26 en los modelos A+/B+). Como nuestra placa auxiliar emplea
la fila inferior del conector, slo dispondremos de 9 seales.

Figura 4.3: Posicin del puerto GPIO
Los puertos del GPIO estn mapeados en memoria, tomando como base la di-
reccin 0x20200000. Para nuestros propsitos de esta leccin nos basta con acceder
a los puertos GPFSELn, GPSETn y GPCLRn. A continuacin tenemos la tabla con
las direcciones de estos puertos.
GPFSELn
Las 54 seales/pines las separamos en 6 grupos funcionales de 10 seales/pines
cada uno (excepto el ltimo que es de 4) para programarlas mediante GPFSELn.
El LED que queremos controlar se corresponde con la seal nmero 9 del puerto
GPIO. Se nombran con GPIO ms el nmero correspondiente, en nuestro caso sera
GPIO 9. Ntese que la numeracin empieza en 0, desde GPIO 0 hasta GPIO 53.
As que la funcionalidad desde GPIO 0 hasta GPIO 9 se controla con GPFSEL0,
desde GPIO 10 hasta GPIO 19 se hace con GPFSEL1 y as sucesivamente. Nosotros
queremos encender el primer LED rojo de la placa auxiliar. En la figura B.3 vemos
que el primer LED rojo se corresponde con GPIO 9. Para cambiar la funcionalidad de
GPIO 9 nos toca actuar sobre GPFSEL0. Por defecto cuando arranca la Raspberry

Direccin Nombre Descripcin Tipo

20200000 GPFSEL0 Selector de funcin 0 R/W
2020000C GPFSEL3 Selector de funcin 3 R/W
2020001C GPSET0 Pin a nivel alto 0 W
20200020 GPSET1 Pin a nivel alto 1 W
20200028 GPCLR0 Pin a nivel bajo 0 W
2020002C GPCLR1 Pin a nivel bajo 1 W
todos los pines estn preconfigurados como entradas, con lo que los LEDs de nuestra
placa auxiliar estn apagados. Es ms, aunque lo configuremos como salida, tras el
reset, los pines se inicializan al valor cero (nivel bajo), por lo que podemos presuponer
que todos los LEDs estarn apagados, incluso despus de programarlos como salidas.
El puerto GPFSEL0 contiene diez grupos funcionales llamados FSELx (del 0 al
9) de 3 bits cada uno, quedando los dos bits ms altos sin usar. Nos interesa cambiar
FSEL9, que sera el que se corresponde con el primer LED rojo, el que queremos
encender. Las posibles configuraciones para cada grupo son:
000 = GPIO Pin X es una entrada
001 = GPIO Pin X es una salida
100 = GPIO Pin X toma funci n alternativa 0
Las funciones alternativas son para dotar a los pines de funcionalidad especficas
como puertos SPI, UART, audio PCM y cosas parecidas. La lista completa est en
la tabla 6-31 (pgina 102) del datasheet [4]. Nosotros queremos una salida genrica,
as que nos quedamos con el cdigo 001 para el grupo funcional FSEL9 del puerto
GPFSEL0 que es el que corresponde al GPIO 9.
GPSETn y GPCLRn
Los 54 pines se reparten entre dos puertos GPSET0/GPCLR0, que contienen los
32 primeros, y en GPSET1/GPCLR1 estn los 22 restantes, quedando libres los 10
bits ms significativos de GPSET1/GPCLR1.
Una vez configurado GPIO 9 como salida, ya slo queda saber cmo poner un

cero o un uno en la seal GPIO 9, para apagar y encender el primer LED de la placa
auxiliar respectivamente (un cero apaga y un uno enciende el LED).
Para ello tenemos los puertos GPSETn y GPCLRn, donde GPSETn pone un 1
y GPCLRn pone un 0. En principio parece enrevesado el tener que usar dos puer-
tos distintos para escribir en el puerto GPIO, pero no olvidemos que para ahorrar
recursos varios pines estn empaquetados en una palabra de 32 bits. Si slo tuvi-
ramos un puerto y quisiramos alterar un nico pin tendramos que leer el puerto,
modificar el bit en cuestin sin tocar los dems y escribir el resultado de nuevo en el
puerto. Por suerte esto no es necesario con puertos separados para setear y resetear,
tan slo necesitamos una escritura en puerto poniendo a 1 los bits que queramos
setear/resetear y a 0 los bits que no queramos modificar.
En la figura 4.4 vemos cmo est hecho el conexionado de la placa auxiliar.
Figura 4.4: Correspondencia LEDs y GPIO
En nuestro primer ejemplo de Bare Metal slo vamos a encender el primer LED
rojo de la placa auxiliar, que como hemos dicho se corresponde con el GPIO 9 as
que tendremos que actuar sobre el bit 9 del registro GPSET0.
Resumiendo, los puertos a los que accedemos para encender y apagar el LED
vienen indicados en la figura 4.5.
El siguiente cdigo (listado 4.2) muestra cmo hemos de proceder.

Figura 4.5: Puertos LED

.set GPBASE, 0x20200000
.set GPFSEL0, 0x00
.set GPSET0, 0x1c
.text
ldr r0, = GPBASE
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
str r1, [ r0, # GPFSEL0 ] @ Configura GPIO 9
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
str r1, [ r0, # GPSET0 ] @ Enciende GPIO 9
infi : b infi
El acceso a los puertos lo hemos hecho usando la direccin base donde estn
mapeados los perifricos 0x20200000. Cargamos esta direccin base en el registro
r0 y codificamos los accesos a los puertos E/S con direccionamiento a memoria
empleando distintas constantes como desplazamiento en funcin del puerto al que
queramos acceder.
El cdigo simplemente escribe dos constantes en dos puertos: GPFSEL0 y GPSET0.
Con la primera escritura configuramos el LED como salida y con la segunda escritura
lo encendemos, para finalmente entrar en un bucle infinito con infi: b infi.

Otros puertos
Ya hemos explicado los puertos que vamos a usar en este captulo, pero el dis-
positivo GPIO tiene ms puertos.
Figura 4.6: Otros puertos del GPIO (1 parte)
En la figura 4.6 tenemos los siguientes:
GPLEVn. Estos puertos devuelven el valor del pin respectivo. Si dicho pin est
en torno a 0V devolver un cero, si est en torno a 3.3V devolver un 1.
GPEDSn. Sirven para detectar qu pin ha provocado una interrupcin en caso
de usarlo como lectura. Al escribir en ellos tambin podemos notificar que ya
hemos procesado la interrupcin y que por tanto estamos listos para que nos
vuelvan a interrumpir sobre los pines que indiquemos.
GPRENn. Con estos puertos enmascaramos los pines que queremos que provo-
quen una interrupcin en flanco de subida, esto es cuando hay una transicin
de 0 a 1 en el pin de entrada.
GPFENn. Lo mismo que el anterior pero en flanco de bajada.
El resto de puertos GPIO se muestran en la figura 4.7.

Estos registros son los siguientes:
GPHENn. Enmascaramos los pines que provocarn una interrupcin al detectar

un nivel alto (3.3V) por dicho pin.

Figura 4.7: Otros puertos del GPIO (2 parte)
GPLENn. Lo mismo que el anterior pero para un nivel bajo (0V).
GPARENn y GPAFENn. Tienen funciones idnticas a GPRENn y GPFENn, pero

permiten detectar flancos en pulsos de poca duracin.
GPPUD y GPPUDCLKn. Conectan resistencias de pull-up y de pull-down sobre los

pines que deseemos. Para ms informacin ver el ltimo ejemplo del siguiente
captulo.
4.2.2. Temporizador del sistema

El temporizador del sistema es un reloj que funciona a 1MHz y en cada paso
incrementa un contador de 64bits. Este contador viene muy bien para implementar
retardos o esperas porque cada paso del contador se corresponde con un microse-
gundo. Los puertos asociados al temporizador son los de la figura 4.8. Bsicamente
encontramos un contador de 64 bits y cuatro comparadores. El contador est dividi-
do en dos partes, la parte baja CLO y la parte alta CHI. La parte alta no nos resulta

96 4.3. Ejemplos de programas Bare Metal
interesante, porque tarda poco ms de una hora (232 s) en incrementarse y no va

asociado a ningn comparador.
Figura 4.8: System Timer
Los comparadores son puertos que se pueden modificar y se comparan con CLO.
En el momento que uno de los 4 comparadores coincida y estn habilitadas las
interrupciones para dicho comparador, se produce una interrupcin y se activa el
correspondiente bit Mx asociado al puerto CS (para que en la rutina de tratamiento
de interrupcin o RTI sepamos qu comparador ha provocado la interrupcin). Los
comparadores C0 y C2 los emplea la GPU internamente, por lo que nosotros nos
ceiremos a los comparadores C1 y C3.
Las interrupciones las veremos en la siguiente leccin. Por ahora slo vamos a
acceder al puerto CLO para hacer parpadear un LED a una frecuencia determinada.
El esquema funcional del System Timer se muestra en la figura 4.9.
4.3. Ejemplos de programas Bare Metal

4.3.1. LED parpadeante con bucle de retardo
La teora sobre encender y apagar el LED la sabemos. Lo ms sencillo que pode-
mos hacer ahora es hacer que el LED parpadee continuamente. Vamos a intruducir
el siguiente programa en la Raspberry, antes de probarlo piensa un poco cmo se
comportara el cdigo del listado 4.3.

Figura 4.9: Esquema funcional del System Timer

.set GPFSEL0, 0x00
.set GPSET0, 0x1c
.set GPCLR0, 0x28
.text
ldr r0, = GPBASE
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
str r1, [ r0, # GPFSEL0 ] @ Configura como salida
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
bucle : mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
str r1, [ r0, # GPSET0 ] @ Enciende
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
str r1, [ r0, # GPCLR0 ] @ Apaga
b bucle
Para compilar y ejecutar este ejemplo sigue los pasos descritos en 4.1.2. Al eje-
cutar el kernel.img resultante comprobamos que el LED no parpadea sino que est
encendido con menos brillo del normal. En realidad s que lo hace, slo que nuestro
ojo es demasiado lento como para percibirlo. Lo siguiente ser ajustar la cadencia
del parpadeo a un segundo para que podamos observar el parpadeo. La secuencia
sera apagar el LED, esperar medio segundo, encender el LED, esperar otro me-
dio segundo y repetir el bucle. Sabemos que el procesador de la Raspberry corre a
700MHz por lo que vamos a suponer que tarde un ciclo de este reloj en ejecutar cada

instruccin. En base a esto vamos a crear dos bucles de retardo: uno tras apagar el
LED y otro tras encenderlo de 500ms cada uno. Un bucle de retardo lo nico que
hace es esperar tiempo sin hacer realmente nada.
Si suponemos que cada instruccin consume un ciclo y teniendo en cuenta que el
bucle de retardo tiene 2 instrucciones, cada iteracin del bucle consume 2 ciclos. A
700 MHz (7108 ciclos/segundo) un ciclo consume 1/(7 108 ) segundos que es igual
a 1,42109 s (aproximadamente 1,5 ns). As que cada iteracin en principio consume
3 ns y para consumir 500 ns necesitamos 500 103 /(3 109 ) = 166,66 106 , es
decir ms de 166 millones de iteraciones.
Si usamos ese nmero de iteraciones observaremos como la cadencia del LED
es ms lenta de lo esperado, lo que quiere decir que cada iteracin del bucle de
retardo tarda ms de los dos ciclos que hemos supuesto. Probamos con cronmetro
en mano distintos valores para las constantes hasta comprobar que con 7 millones de
iteraciones del bucle se consigue ms o menos el medio segundo buscado. Haciendo
cuentas nos salen 50 ciclos por iteraccin, bastante ms de los 2 ciclos esperados.
Esto se debe a una dependencia de datos (ya que el flag que altera la orden subs es
requerido justo despus por la instruccin bne) y que los saltos condicionales suelen
ser lentos.
Listado 4.4: Parte de esbn4.s
.set GPFSEL0, 0x00
.set GPSET0, 0x1c
.set GPCLR0, 0x28
.text
ldr r0, = GPBASE
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
bucle : ldr r2, = 7000000

ret1 : subs r2, # 1 @ Bucle de retardo 1
bne ret1
str r1, [ r0, # GPSET0 ] @ Enciende el LED
ldr r2, = 7000000
ret2 : subs r2, # 1 @ Bucle de retardo 2
bne ret2
str r1, [ r0, # GPCLR0 ] @ Enciende el LED
b bucle @ Repetir para siempre

4.3.2. LED parpadeante con temporizador

Viendo lo poco preciso que es el temporizar con el bucle de retardo, vamos a
sincronizar leyendo continuamente el valor del System Timer. Como el temporizador
va a 1MHz, para temporizar medio segundo lo nico que tenemos que hacer es esperar
a que el contador se incremente en medio milln. El cdigo final quedara as:
.set GPFSEL0, 0x00
.set GPSET0, 0x1c
.set GPCLR0, 0x28
.set STBASE, 0x20003000
.set STCLO, 0x04
.text
ldr r0, = GPBASE
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
ldr r2, = STBASE
bucle : bl espera @ Salta a rutina de espera

str r1, [ r0, # GPSET0 ]
bl espera @ Salta a rutina de espera
str r1, [ r0, # GPCLR0 ]
b bucle
/* rutina que espera medio segundo */

espera : ldr r3, [ r2, # STCLO ] @ Lee contador en r3
ldr r4, = 500000
add r4, r3 @ r4 = r3 + medio mill n
ret1 : ldr r3, [ r2, # STCLO ]
cmp r3, r4 @ Leemos CLO hasta alcanzar
bne ret1 @ el valor de r4
bx lr
4.3.3. Sonido con temporizador

Este ejemplo es exactamente el mismo que el anterior, tan slo hemos cambiado
el pin del LED (GPIO 9) por el pin asociado al altavoz de nuestra placa de expan-

sin (GPIO 4). Tambin modificamos el tiempo de espera para producir un sonido
audible.
Vamos a producir un tono de 440 Hz. Para ello generamos una onda cuadrada
por dicho pin, que no es ms que una serie de ceros y unos consecutivos de idntica
duracin. A esta duracin la llamamos semi-periodo, y es la que queremos calcular.
Como el periodo es el inverso de la frecuencia, tenemos que periodo = 1/(440s1 ) =
2,272103 s, por lo que el semi-periodo buscado es 2,272103 s/2 = 1,136103 s
o lo que es lo mismo, 1136 microsegundos.
Listado 4.6: Parte de esbn6.s
ldr r0, = GPBASE
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
ldr r2, = STBASE
bucle : bl espera @ Salta a rutina de espera

bl espera @ Salta a rutina de espera
b bucle
/* rutina que espera 1136 microsegundos */

espera : ldr r3, [ r2, # STCLO ] @ Lee contador en r3
ldr r4, = 1136
add r4, r3 @ r4 = r3 + 1136
ret1 : ldr r3, [ r2, # STCLO ]
cmp r3, r4 @ Leemos CLO hasta alcanzar
bne ret1 @ el valor de r4
bx lr

4.4. Ejercicios
4.4.1. Cadencia variable con bucle de retardo
Usando la tcnica del bucle de retardo haz que el LED parpadee cada vez ms
rpido, hasta que la cadencia sea de 1/4 de segundo. Una vez llegues a esta cadencia
salta de golpe a la cadencia original de 1 segundo. El tiempo que se tarda en pasar
de una cadencia a otra puede ser el que quieras, siempre que sea suficiente para
poder apreciar el efecto.
4.4.2. Cadencia variable con temporizador

Repite el ejercicio anterior pero empleando el temporizador interno. Durante los
10 primeros segundos aumentamos la cadencia del LED desde 1 segundo hasta los
250ms, y en los ltimos 10 segundos disminuimos la cadencia al mismo ritmo de tal
forma que el ciclo completo se repite cada 20 segundos.
4.4.3. Escala musical

Escribe un programa que haga sonar el altavoz con las notas Do, Mi y Sol (de
la quinta octava) durante tres segundos cada una de ellas. Las frecuencias de estas
notas son:
Nota Frecuencia
Do 523 Hz
Mi 659 Hz
Sol 784 Hz
Captulo 5
Interrupciones hardware
Contenido
5.1 Lectura previa . . . . . . . . . . . . . . . . . . . . . . . . . 104
5.1.1 El sistema de interrupciones del ARM . . . . . . . . . . . 104
5.1.2 Rutina de tratamiento de interrupcin . . . . . . . . . . . 109
5.1.3 Pasos para configurar las interrupciones . . . . . . . . . . 110
5.1.4 El controlador de interrupciones . . . . . . . . . . . . . . 112
5.1.5 Ejemplo. Encender LED rojo a los 4 segundos . . . . . . . 114
5.1.6 Ejemplos de aplicacin . . . . . . . . . . . . . . . . . . . . 118
5.1.7 Parpadeo de todos los LEDs . . . . . . . . . . . . . . . . . 119
5.1.8 Control de LEDs rojos con pulsadores . . . . . . . . . . . 123
5.1.9 Parpadeo secuencial de LEDs con sonido por altavoz . . . 127
5.1.10 Manejo de FIQs y sonidos distintos para cada LED . . . . 133
5.1.11 Control de luces/sonido con pulsadores en lugar tempori-
zadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
5.2 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
5.2.1 Todo con IRQs . . . . . . . . . . . . . . . . . . . . . . . . 142
5.2.2 Alargar secuencia a 10 y parpadeo . . . . . . . . . . . . . 142
5.2.3 Tope de secuencia y limitar sonido . . . . . . . . . . . . . 142
5.2.4 Reproductor de meloda sencilla . . . . . . . . . . . . . . . 143
Objetivos: En esta sesin vamos a realizar programas que utilizan dispositivos

de E/S haciendo uso del sistema de interrupciones hardware. Para poder programar
los distintos parmetros que configuran el entorno de las interrupciones es necesario
103
conocer de forma detallada cmo funcionan los puertos asociados, ya que ste es el
mecanismo tpico mediante el cual el procesador se comunica con los perifricos.
Hacemos incapi en lo de hardware porque las interrupciones software no son
ms que las llamadas a sistema que vimos en el captulo anterior. Ambas comparten
vector de interrupciones, pero las interrupciones software son ms bien llamadas a
subrutinas.
5.1. Lectura previa

El microprocesador se encuentra en un entorno donde existen otros componentes.
La forma de comunicacin ms usual entre estos componentes y el microprocesador
se denomina interrupcin. Bsicamente, una interrupcin es una peticin que se hace
a la CPU para que detenga temporalmente el trabajo que est realizando y ejecute
una rutina determinada.
5.1.1. El sistema de interrupciones del ARM

Decimos que las interrupciones del ARM son autovectorizadas. Cada tipo de
interrupcin lleva asociado un nmero (que llamamos nmero de interrupcin,
N I) que identifica el tipo de servicio a realizar. En total hay 8 tipos de interrup-
ciones. A partir de dicho nmero se calcula la direccin a la que salta la CPU para
atender dicha interrupcin. A diferencia de otras arquitecturas donde los vectores
contienen las direcciones de las rutinas de tratamiento, en ARM no tenemos direc-
ciones sino instrucciones. Cada vector contiene normalmente un salto a la rutina de
tratamiento correspondiente. Dicha rutina se suele llamar RTI (Rutina de Tra-
tamiento de Interrupcin). En la arquitectura ARMv6 todos los vectores de
interrupcin se almacenan en una zona de memoria llamada tabla de vectores de
interrupcin. Esta tabla comienza en la direccin fsica 0x00000000 (aunque puede
cambiarse por 0xffff0000) y acaba en 0x0000001f y contiene en total 8 vectores de
interrupcin. Cuando termina de ejecutarse una RTI, el procesador contina ejecu-
tando la instruccin siguiente a la que se estaba ejecutando cuando se produjo la
interrupcin.
Existen dos tipos de interrupciones: hardware y software. Las interrupciones
hardware son aquellas en las que su activacin est condicionada por el hardware
del sistema, ya sea por: 1) excepciones provocadas en la ejecucin de alguna ins-
truccin o error grave, o 2) provocadas por la placa base o por cualquier tarjeta
implicada en un canal de E/S.
La lista del vector de interrupciones es la siguiente.

Captulo 5. Interrupciones hardware 105
Excepcin Tipo Desplaz. Modo

Reset Interrupcin 0x00 Supervisor
Instruccin no definida Excepcin 0x04 Indefinido
Interrupcin software Int. software 0x08 Supervisor
Error en prefetch Excepcin 0x0C Abort
Error en datos Excepcin 0x10 Abort
Reservado - 0x14 Reservado
IRQ Interrupcin 0x18 IRQ
FIQ Interrupcin 0x1C FIQ
Tabla 5.1: Vector de interrupciones
La ltima columna se refiere al Modo de operacin que comentamos en el primer

captulo y que forma parte del registro cpsr (ver figura 5.1). Es un estado en el que
se encuentra el procesador con una serie de privilegios con respecto a otros modos
y que gracias a ellos podemos construir un sistema operativo con diferentes capas.
Figura 5.1: Registro cpsr
Cada modo tiene sus propios registros sp, lr y spsr (Saved Program Status Re-
gister) de tal forma que no alteramos la pila ni los flags de la secuencia de programa
que interrumpimos. Incluso el modo FIQ tiene 5 registros generales propios (desde
r8 hasta r12), de esta forma si los empleamos en nuestra rutina de tratamiento
no tendremos que salvaguardarlos en pila. En la figura 5.2 observamos los registros
propios mencionados marcados con un tringulo.
Reset es la excepcin que permitira un reset en caliente dentro de la CPU.

Desgraciadamente en la Raspberry no hay forma conocida de forzar esta ex-
cepcin. Los pines del conector P6 en la Raspberry 2.0 y RUN en el modelo B+
(ver figura C.3) provocan una secuencia completa de arranque, la que comien-

Figura 5.2: Registros segn modo de operacin
za con el bootloader de la GPU y acaba cediendo el control a la CPU en la

direccin 0x8000.
Instruccin no definida se produce cuando en el flujo de instrucciones nos

encontramos un cdigo de operacin que no se corresponde con ninguna ins-
truccin. Normalmente esto se produce por una corrupcin en la memoria de
programa o bien que hemos saltado errneamente a una zona donde hay da-
tos. Tambin se puede dar el caso de que intentemos ejecutar cdigo ARM
para una plataforma ms moderna y nos encontremos con una instruccin no
soportada por el procesador que tenemos.
Las interrupciones software son subrutinas que se incluyen en el sistema ope-

rativo y que son llamadas desde el programa ejecutando la instruccin swi #n.
No interrumpen realmente nada, pero se denominan as porque el mecanismo
de funcionamiento es el mismo que en las hardware.
Luego tenemos los errores en prefetch y datos. Un error de prefetch se produce

cuando tratamos de ejecutar una instruccin que momentos antes hemos mo-
dificado. Es poco frecuente y para que se produzca debemos escribir cdigo

que sea automodificable, que es una prctica no deseable y apenas utilizada

en dicha arquitectura. Los errores de datos son generados normalmente por el
manejador de memoria y responden a fallos de alineacin, de traslacin, de
dominio o de permisos.
Lo siguiente es una entrada reservada, no tiene ninguna funcionalidad ahora

pero es probable que en futuras extensiones s que la tenga.
Por ltimo estn las excepciones que nos interesan y que trataremos en este
captulo, que son las interrupciones normales IRQ y las interrupciones rpidas
FIQ.
Puesto que cada interrupcin, N I, lleva asociada una rutina, de alguna forma,
debe haber una correspondencia entre este N I y la ubicacin del vector asociado, que
contiene la instruccin de salto a la rutina que debe ejecutar cuando se produce la
interrupcin. La forma de hacerlo es multiplicar por cuatro el nmero de interrupcin
para obtener un desplazamiento (N I*4). Se multiplica por 4 porque cada vector de
excepcin ocupa 4 bytes (es lo que ocupa una instruccin en ARM).
Cuando se activa una interrupcin, la CPU detiene su trabajo para atenderla.
Despus, contina su trabajo donde lo dej. Los pasos a seguir para que esto sea
posible son:
1. Cuando se activa la interrupcin, se termina la ejecucin de la instruccin

en curso. A continuacin se hace una copia cpsr en el registro propio spsr
correspondiente. De esta forma se recuerdan los flags de estado y el modo que
haba antes de la interrupcin. Una vez hecha la copia se procede a cambiar
cpsr, conmutando al modo correspondiente segn la tabla 5.1.
2. Seguidamente a lo anterior se almacena en lr (en su registro propio del modo)

el contenido de pc+8 (salvo si es un error en datos que sera pc+12). La
razn de estos desplazamientos es puramente tcnica, debido al segmentado
de la CPU en el momento de hacer la copia el registro pc se ha incrementado
en 1 2 instrucciones.
PC Ins. Nombre
x-4 i-1 Instruccin anterior
x i Instruccin interrumpida
x+4 i+1 Instruccin siguiente
x+8 i+2 ...
x+12 i+3 ...

Podemos observarlo grficamente en la figura 5.3.
Figura 5.3: Diagrama de una interrupcin
3. Luego se salta al vector correspondiente (N I*4). En esa posicin del vector se

encuentra una instruccin de salto a la RTI correspondiente.
4. Se ejecuta la rutina.
5. La ltima instruccin de la rutina es subs pc, lr, #4, que se encarga de res-
taurar los flags originales y el modo copiando spsr en cpsr. Adems volvemos
al punto donde se interrumpi copiando de lr a pc (con el desplazamiento
correspondiente).
6. Se contina ejecutando la tarea inicial.
El registro cpsr contiene 3 flags globales mediante los cuales podemos habilitar
o inhabilitar las interrupciones: uno para Abort llamado A, otro para IRQ llamado
I y el ltimo para FIQ denominado F.
El manejo de estos flags corre a cuenta del usuario, en ningn momento la CPU
enmascara dichos flags. Por esta razn, si queremos dar prioridad a una interrupcin
en particular para no ser interrumpidos nuevamente, debemos enmascarar dichos
flags al comienzo de su RTI.

5.1.2. Rutina de tratamiento de interrupcin

Es el segmento de cdigo que se ejecuta para atender a una interrupcin. Una vez
se haya ejecutado dicha rutina, retomamos la ejecucin normal de nuestro programa,
justo despus de la instruccin donde lo habamos interrumpido. Cada rutina de tra-
tamiento debe atender a todas las posibles fuentes de interrupcin de su mismo tipo,
con lo que al comienzo de la interrupcin se suelen acceder a los puertos asociados
para detectar qu perifrico ha causado la interrupcin y actuar en consecuencia.
Si nos interesan IRQ y FIQ, a lo sumo tendremos que escribir dos rutinas de
tratamiento distintas. Si se produce una IRQ, se ejecutar el cdigo que se encuentre
en la direccin 0x0018, mientras que si lo que salta es una FIQ, la direccin a
ejecutar ser 0x001C. La diferencia entre una IRQ y una FIQ es que esta ltima
tiene sus propios registros desde r8 hasta r12 asociados al modo de operacin, con
lo que podemos prescindir del salvado y recuperacin de estos registros en la RTI,
ahorrando un tiempo que en determinadas aplicaciones de tiempo real puede ser
decisivo.
El esqueleto de una RTI es el siguiente.
irq_handler :
push { lista registros }
...
pop { lista registros }
subs pc, lr, # 4
Vemos que a diferencia de las subrutinas donde salamos con lr, en una RTI
salimos con lr-4 (si es un error en datos sera lr-8), a ello se debe que la ltima
instruccin sea subs en lugar de movs. Y porqu hay un sufijo s al final de la
instruccin sub? Pues porque se trata de instruccin especial que sirve para restaurar
el registro cpsr que haba antes de la interrupcin (copia spsr_irq o spsr_fiq en
cpsr).
Imaginemos que el programa principal est en modo supervisor y que la inte-
rrupcin que esperamos es del tipo IRQ. Cada modo de operacin (en particular
el modo IRQ) tiene 3 registros replicados: sp, lr y spsr. Para evitar confusiones
los nombramos con los sufijos de modo _svc y _irq correspondientes. Cuando ocu-
rre una interrupcin pasamos de modo supervisor a modo IRQ, pero antes hemos
guardado el registro cpsr en spsr_irq.
Los registros sp_svc y lr_svc no se tocan para nada, con lo que no alteramos
ni la pila ni el registro de retorno del modo supervisor. El registro lr_irq se carga
apuntando a la instruccin i+2 siguiente a la que fue interrumpida, pc+8. El resto
de registros debemos salvarlos en pila si tenemos la intencin de modificarlos en
nuestra RTI, al tener registro propio sp_irq se trata de una pila independiente que
no interfiere con la principal sp_svc. Luego se ejecuta el cdigo particular de la RTI,

empleando a nuestro antojo los registros previamente salvados, y antes de acabar la

RTI recuperamos con su pop correspondiente.
Al terminar la interrupcin restauramos pc partiendo de lr_irq y cpsr del
registro spsr_irq. Esto ltimo fuerza un cambio de modo de IRQ a supervisor,
conmutando sp y lr a sus registros propios sp_svc y lr_svc. Con todo esto conse-
guimos volver exactamente al punto del que partamos minimizando las operaciones
que tiene que hacer la RTI y por tanto el retardo asociado. En otras arquitecturas
adems de delegar en la RTI este trabajo, se usa la misma pila de programa, lo que
puede ocasionar problemas si nos importa lo que hay debajo de sta.
5.1.3. Pasos para configurar las interrupciones

Nosotros vamos a tratar un caso sencillo de programa principal en el cual hacemos
las inicializaciones correspondientes para luego meternos en un bucle infinito y que
las interrupciones hagan su trabajo. Las cosas se pueden complicar metiendo cdigo
en el programa principal concurrente con las interrupciones. Un ejemplo de esto sera
una rutina que dibuja la pantalla en el programa principal, mientras que se aceptan
interrupciones para registrar las pulsaciones del teclado.
Sin embargo nuestro programa principal tras la inicializacin ser una instruccin
que salta a s misma continuamente, bucle: b bucle.
El orden recomendado es el siguiente, aunque se puede cambiar el mismo salvo
el ltimo punto.
1. Escribimos en el vector de interrupciones la instruccin de salto necesaria

a nuestra RTI. Nosotros emplearemos una macro llamada ADDEXC que tiene
2 parmetros, vector y direccin de la RTI. La macro genera y escribe el
cdigo de operacin del salto, para ver los detalles consultar apndice A. En
nuestros ejemplos tendremos IRQs (0x18) y FIQs (0x1c), por lo que como
mucho haremos dos invocaciones a dicha macro (para dos RTIs distintas).
.macro ADDEXC vector, dirRTI
ldr r1, =(\ dirRTI -\ vector + 0xa7fffffb )
ROR r1, # 2
str r1, [ r0, #\ vector ]
.endm
2. Inicializamos el puntero de pila (registro sp) en todos los modos de operacin.

Al cambiar el modo de operacin hay que tener cuidado de no modificar la
mscara global de interrupciones, ya que comparten el mismo byte bajo de
cpsr. Como sabemos que al comienzo estaban deshabilitadas, las mantenemos
igual (bits I y F a 1. Los punteros tienen que alojar la pila en zonas distintas
donde sepamos que no habr conflictos con la memoria de programa. En los

ejemplos en los que usemos FIQ e IRQ inicializamos la pila de FIQ a 0x4000,
la de IRQ a 0x8000 y la del modo Supervisor a 0x8000000. Como la memoria
de programa empieza en 0x8000 y la pila crece hacia abajo, tendremos 16K
de pila en modo IRQ, otros 16K en modo FIQ y 128Mb a compartir entre
programa principal y pila de programa. El mapa de memoria sera el indicado
en la figura 5.4
Figura 5.4: Mapa de memoria en nuestros ejemplos
3. Escribimos cdigo de inicializacin ajeno al proceso de interrupcin, como por

ejemplo configurar los GPIOs a salidas donde queramos que acte un LED.
4. Ahora viene la inicializacin de las interrupciones. Aqu le decimos al sistema

qu fuentes pueden provocar interrupciones, escribiendo en los puertos asocia-
dos.
5. El ltimo paso es habilitar las interrupciones globalmente escribiendo en el

registro cpsr. Lo hacemos indirectamente va otro registro, y la instruccin
tiene otro nombre pero hace lo mismo que un mov. En concreto se llama msr,
y tambin hay otra equivalente mrs si lo que queremos es leer de cpsr a un
registro.
6. Despus de esto se acaba la inicializacin y tendramos el bucle infinito del

que consta nuestro programa principal. Si todo ha ido bien las rutinas de tra-
tamiento de interrupcin se encargarn de hacer funcionar nuestro programa
como queramos.

5.1.4. El controlador de interrupciones

Los puertos que componen el controlador de interrupciones son los siguientes.
Figura 5.5: Interrupciones
Las FIQs slo tienen un puerto de control asociado, quedando todo el detalle en
las IRQs. Hay tres grupos de tres puertos cada uno. El primer grupo (Pending) sirve
para indicar que hay una interrupcin pendiente, el segundo (Enable) es para ha-
bilitar las interrupciones y el tercero (Disable) para deshabilitarlas. Dentro de cada
grupo tenemos un puerto bsico que tiene un resumen sobre el mapa de interrup-
ciones y otros dos puertos que indican con ms detalle la fuente de la interrupcin.
En el puerto bsico hay fuentes individuales GPU IRQ x y bits que engloban a varias
fuentes Bits in PR1, que por ejemplo indica que el origen hay que buscarlo en el
puerto 1. En el puerto 1 estn las primeras 32 posiciones del mapa de interrupciones,
mientras que en el puerto 2 estn las 32 ltimas.
La documentacin oficial sobre el mapa de interrupciones est incompleta, pero
buscando un poco por internet se puede encontrar que las interrupciones asociadas
al System Timer se controlan con los 4 primeros bits de la tabla (uno para cada
comparador).
En la figura 5.6 vemos los puertos ordenados en grupos.
La forma habitual de trabajar es usar el puerto apropiado del grupo Enable para
habilitar la fuente de interrupcin que queramos que nos interrumpa. Luego en el
caso de ser interrumpidos podemos detectar cul ha sido la fuente leyendo el mismo

Figura 5.6: Agrupacin de puertos de interrupciones
ndice Fuente
0-63 Interrupciones IRQ 1 y 2 (ver figura 5.5)
64 ARM Timer
65 ARM Mailbox
66 ARM Doorbell 0
67 ARM Doorbell 1
68 GPU0 detenida
69 GPU1 detenida
70 Acceso ilegal de tipo 1
71 Acceso ilegal de tipo 2
bit del grupo Pending y finalmente, si pasamos a otra seccin del programa donde
no queremos que nos interrumpa ms dicha fuente la desactivamos con el grupo
Disable.
A parte del controlador de interrupciones, cada dispositivo tiene su propio me-
canismo de habilitar/deshabilitar y detectar/notificar la fuente de interrupcin. En
el caso del GPIO tenemos los puertos GPRENn, GPFENn, GPHENn, GPLENn, GPARENn y
GPAFENn para habilitar/deshabilitar. Para detectar/notificar estn los GPEDSn.
Para el temporizador tenemos que STCS hace las funciones de deteccin y notifica-
cin. No existen puertos especficos para habilitar/deshabilitar ya que el controlador
de interrupciones permite habilita/deshabilitar cada comparador por separado.
El nico puerto que nos falta por ver es FIQ control INTFIQCON que hemos
mostrado en la figura 5.5. Antes mostraremos la lista de fuentes de interrupcin
aplicables a este puerto.
Son las mismas fuentes que en IRQ pero condensadas en un nico puerto. De 0
a 31 coincide con la tabla IRQ 1, de 32 a 63 con IRQ 2 y de 64 en adelante con IRQ

Basic.
El puerto INTFIQCON se programa con los 8 bits inferiores, indicando en el bit 7
si queremos habilitar la fuente, y en los bits del 0 al 6 ponemos el ndice de la fuente
que se corresponde con la lista. A diferencia de las IRQ, con las FIQ slo podemos
atender a una fuente de interrupcin.
5.1.5. Ejemplo. Encender LED rojo a los 4 segundos

Se trata de programar el comparador y las interrupciones para que transcurrido
un tiempo determinado se produzca una interrupcin, dentro de la cual se encienda
el LED. Es un caso muy sencillo porque slo se va a producir una interrupcin que
viene de una sola fuente, por lo que en la RTI lo nico que haremos es encender el
LED.
El diagrama que vamos a usar es el siguiente.
1. Escribimos en el vector de interrupciones

Invocamos la macro para una IRQ, pasndole la etiqueta de nuestra RTI irq_handler.
ADDEXC 0x18, irq_handler
2. Inicializamos punteros de pila

La nica forma de acceder a los registros sp_irq y sp_fiq es cambiando de
modo y modificando el registro sp correspondiente.

El modo viene indicado en la parte ms baja del registro cpsr, el cual modifica-
remos con la instruccin especial msr. En la figura 5.1 vemos el contenido completo
del registro cpsr. Como cpsr es un registro muy heterogneo, usamos sufijos para
acceder a partes concretas de l. En nuestro caso slo nos interesa cambiar el byte
bajo del registro, aadimos el sufijo _c llamndolo cpsr_c, para no alterar el resto
del registro. Esta parte comprende el modo de operacin y las mscaras globales de
las interrupciones. Otra referencia til es cpsr_f que modifica nicamente la parte
de flags (byte alto). Las otras 3 referencias restantes apenas se usan y son cpsr_s
(Status) para el tercer byte, cpsr_x (eXtended) para el segundo byte y cpsr_csxf
para modificar los 4 bytes a la vez.
En la siguiente tabla vemos cmo se codifica el modo de operacin.
Hex Binario Modo de operacin

0x10 10000 Usuario
0x11 10001 FIQ
0x12 10010 IRQ
0x13 10011 Supervisor
0x16 10110 Monitor seguro
0x17 10111 Abort
0x1B 11011 Indefinido
0x1F 11111 Sistema
Como las interrupciones globales de IRQ y FIQ estn desactivadas (estado por
defecto tras el reset), mantenemos a 1 dichos bits.
El cdigo que inicializa los punteros de pila es el siguiente:
mov r0, # 0b11010010 @ Modo IRQ, FIQ & IRQ desact
msr cpsr_c, r0
mov sp, # 0x8000
mov r0, # 0b11010011 @ Modo SVC, FIQ & IRQ desact
msr cpsr_c, r0
mov sp, # 0x8000000
En concreto a 0x8000 y 0x8000000 para los modos IRQ y Supervisor respecti-

vamente.
3. Cdigo de inicializacin ajeno a interrupciones

En el ejemplo que tenemos entre manos se trata de configurar los puertos GPIO
de entrada y de salida, inicializar temporizadores. En casos ms complejos tendra-
mos que inicializar estructuras de datos, rellenar las tablas que sean precalculadas
y en general cualquier tarea de inicializacin requerida para hacer funcionar nuestro
programa.

El cdigo para asignar el sentido al pin GPIO 9 es el siguiente:

ldr r0, = GPBASE
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
str r1, [ r0, # GPFSEL0 ]
Luego programamos el comparador para que salte la interrupcin a los 4,19

segundos:
ldr r0, = STBASE
ldr r1, [ r0, # STCLO ]
add r1, # 0x400000 @ 4,19 segundos
str r1, [ r0, # STC1 ]
4. Inicializamos interrupciones localmente

Consiste en escribir en los puertos asociados dependiendo de las fuentes que
querramos activar. En este primer ejemplo habilitamos el comparador C1 del tem-
porizador como fuente de interrupcin:
ldr r0, = INTBASE
mov r1, # 0b0010
str r1, [ r0, # INTENIRQ1 ]
5. Habilitamos interrupciones globalmente

Se trata de poner a cero el bit correspondiente en cpsr. El siguiente cdigo
habilita interrupciones del tipo IRQ:
mov r0, # 0b01010011 @ Modo SVC, IRQ activo
msr cpsr_c, r0
6. Resto del programa principal

Como hemos adelantado, en todos nuestros ejemplos ser un bucle infinito:
bucle : b bucle
A continuacin mostramos el listado del ejemplo completo:

Listado 5.1: inter1.s

.include " inter.inc "
.text
/* Agrego vector interrupci n */
/* Inicializo la pila en modos IRQ y SVC */

msr cpsr_c, r0
mov sp, # 0x8000
msr cpsr_c, r0
mov sp, # 0x8000000
/* Configuro GPIO 9 como salida */

ldr r0, = GPBASE
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0b00001000000000000000000000000000
/* Programo contador C1 para futura interrupci n */

ldr r0, = STBASE
add r1, # 0x400000 @ 4,19 segundos
str r1, [ r0, # STC1 ]
/* Habilito interrupciones, local y globalmente */

ldr r0, = INTBASE
mov r1, # 0b0010
msr cpsr_c, r0
/* Repetir para siempre */

bucle : b bucle
/* Rutina de tratamiento de interrupci n */

irq_handler :
push { r0, r1 } @ Salvo registros
ldr r0, = GPBASE

/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0

str r1, [ r0, # GPSET0 ] @ Enciendo LED
pop { r0, r1 } @ Recupero registros

subs pc, lr, # 4 @ Salgo de la RTI
Observamos que la RTI es muy sencilla, aparte del esqueleto tenemos tres ins-
trucciones encargadas de encender el LED en cuestin.
5.1.6. Ejemplos de aplicacin

Vamos a crear un archivo inter.inc donde guardaremos las constantes asociadas
a los puertos y tambin la macro ADDEXC, esta ltima se explica en detalle en el
apndice A. De esta forma evitamos escribir siempre las mismas constantes, haciendo
el cdigo ms sencillo de mantener.
Listado 5.2: inter.inc
ROR r1, # 2
.endm
.set GPFSEL0, 0x00
.set GPFSEL1, 0x04
.set GPFSEL2, 0x08
.set GPSET0, 0x1c
.set GPCLR0, 0x28
.set GPEDS0, 0x40
.set GPFEN0, 0x58
.set GPPUD, 0x94
.set GPPUDCLK0, 0x98
.set STBASE, 0x20003000
.set STCS, 0x00
.set STCLO, 0x04
.set STC1, 0x10
.set STC3, 0x18
.set INTBASE, 0x2000b000
.set INTFIQCON, 0x20c
.set INTENIRQ1, 0x210
.set INTENIRQ2, 0x214

El mtodo para incluir el cdigo fuente de un fichero dentro de otro es mediante

la macro .include, todos nuestros ficheros comienzarn con lo siguiente.
5.1.7. Parpadeo de todos los LEDs

Sera hacer lo mismo que en la leccin anterior pero empleando interrupciones
y aplicando la salida simultneamente a los 6 LEDs en lugar de slo al primero.
La novedad en lo que a interrupciones se refiere consiste en reprogramar el com-
parador C1 cada vez que se produzca una interrupcin, de esta forma conseguimos
interrupciones peridicas en lugar de una nica interrupcin.
Veamos el cdigo:
.text

msr cpsr_c, r0
mov sp, # 0x8000
msr cpsr_c, r0
mov sp, # 0x8000000
/* Configuro GPIOs 9, 10, 11, 17, 22 y 27 como salida */

ldr r0, = GPBASE
mov r1, # 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1
ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
/* Programo contador C1 para dentro de 2 microsegundos */

ldr r0, = STBASE
add r1, # 2
str r1, [ r0, # STC1 ]


ldr r0, = INTBASE
mov r1, # 0b0010
msr cpsr_c, r0

bucle : b bucle

irq_handler :
push { r0, r1, r2 }
/* Conmuto variable de estado del LED */

ldr r0, = ledst @ Leo puntero a v. ledst
ldr r1, [ r0 ] @ Leo variable
eors r1, #1 @ Invierto bit 0, act. flag Z
str r1, [ r0 ] @ Escribo variable
/* Enciendo o apago todos los LEDs en funci n del flag Z */

ldr r0, = GPBASE
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
ldr r1, = 0 b 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0
streq r1, [ r0, # GPSET0 ]
strne r1, [ r0, # GPCLR0 ]
/* Reseteo estado interrupci n de C1 */

ldr r0, = STBASE
mov r1, # 0b0010
str r1, [ r0, # STCS ]
/* Programo siguiente interrupci n medio segundo despu s */

ldr r2, = 500000 @ 1 Hz
add r1, r2
str r1, [ r0, # STC1 ]
/* Recupero registros y salgo */

pop { r0, r1, r2 }
subs pc, lr, # 4

/* Ubicaci n de la variable ledst */

ledst : .word 0
Y vamos enumerando, por orden, los pasos que hemos seguido. En primer lugar
apuntamos a nuestra RTI en el vector de interrupciones:
Luego inicializamos los punteros de pila:

msr cpsr_c, r0
mov sp, # 0x8000
msr cpsr_c, r0
mov sp, # 0x8000000
Lo siguiente es configurar los pines GPIO asociados a los 6 LEDs como salidas:
ldr r0, = GPBASE
mov r1, # 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1
ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
Preparamos el comparador C1 para que al cabo de dos microsegundos nos pro-

porcione la primera interrupcin:
ldr r0, = STBASE
add r1, #2
str r1, [ r0, # STC1 ]
Para despus habilitar las interrupciones asociadas al comparador C1:

ldr r0, = INTBASE
mov r1, # 0b0010
Y finalmente habilitar las interrupciones IRQ globalmente, entrando luego en el

bucle infinito:
mov r0, # 0b01010011 @ modo SVC, IRQ activo
msr cpsr_c, r0
bucle : b bucle

Ya hemos terminado con el programa principal, que como veremos ms adelante

va a ser siempre muy parecido.
Lo interesante est en la RTI, que es donde hacemos parpadear los LEDs y
configuramos el comparador para la siguiente interrupcin.
El estado de los LEDs (si estn apagados o encendidos) lo guardamos en la
variable ledst, que conmutamos entre cero y uno mediante un OR exclusivo. Al
actualizar los flags tras esta operacin, tenemos que si el resultado fue cero nos lo
indica el flag Z activo, mientras que estar inactivo en el caso contrario (resultado
1). Mediante las instrucciones de ejecucin condicional streq y strne enviamos la
orden al puerto que enciende los LEDs o al puerto que los apaga, respectivamente:
irq_handler :
push { r0, r1, r2 }
ldr r0, = ledst @ Leo puntero a v. ledst

ldr r1, [ r0 ] @ Leo variable
eors r1, #1 @ Invierto bit 0, act. flag Z
str r1, [ r0 ] @ Escribo variable
ldr r0, = GPBASE

/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
ldr r1, = 0 b 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0
Luego escribimos un 1 en el M1 de CS, para resetear el estado de coincidencia, ya

que de lo contrario el gestor de interrupciones ver el bit siempre a 1 y no lanzar ms
interrupciones. Resulta confuso tener que escribir un 1 en el puerto para almacenar
un 0, pero de un modo similar a lo que ocurre con el puerto GPCLR0 del GPIO es
para ahorrar operaciones y que la RTI sea ms rpida. As no hay que leer el puerto,
aplicar una mscara y volver a escribir en el mismo puerto, con una escritura es
suficiente:
ldr r0, = STBASE
mov r1, # 0b0010
Luego tenemos que actualizar el puerto comparador, de lo contrario tardar poco

ms de una hora en cambiar de estado el LED (es lo que tarda el contador en dar
una vuelta completa). Para ello leemos el contador (CLO) y le aadimos 500000 al
valor ledo. Como cada cuenta equivale a un microsegundo, este aadido al contador
supone medio segundo, lo que nos da la cadencia de un segundo que buscamos. El
resultado de la suma lo escribimos en el comparador (C1):


ldr r2, = 500000 @ 1 Hz
add r1, r2
str r1, [ r0, # STC1 ]
Por ltimo restauramos los registros utilizados y salimos de la RTI. Ms abajo

tenemos la definicin de la variable ledst, como no tenemos seccin de datos aparte
la ponemos al final del cdigo:
pop { r0, r1, r2 }
subs pc, lr, # 4
ledst : .word 0
5.1.8. Control de LEDs rojos con pulsadores

En este ejemplo cambiamos de fuente de interrupcin, en lugar del temporizador
empleamos los pulsadores. Queremos que al pulsar un botn se encienda el LED
rojo del mismo lado del pulsador, dejando el otro apagado.
El esquema sera el de la figura 5.8.

Y el cdigo fuente lo vemos a continuacin:

.text

msr cpsr_c, r0
mov sp, # 0x8000
msr cpsr_c, r0
mov sp, # 0x8000000
/* Configuro GPIOs 9 y 10 como salida */

ldr r0, = GPBASE
mov r1, # 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
/* Enciendo LEDs 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0
/* Habilito pines GPIO 2 y 3 ( botones ) para interrupciones */

mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
str r1, [ r0, # GPFEN0 ]
ldr r0, = INTBASE

mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
msr cpsr_c, r0

bucle : b bucle


irq_handler :
push { r0, r1 }
ldr r0, = GPBASE
/* Apago los dos LEDs rojos 5 43 21 0 98 76 54 3 21 09 87 6 54 32 10 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0
/* Consulto si se ha pulsado el bot n GPIO2 */
ldr r1, [ r0, # GPEDS0 ]
ands r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
/* S : Activo GPIO 9 ; No : Activo GPIO 10 */
movne r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
moveq r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
/* Desactivo los dos flags GPIO pendientes de atenci n
guia bits 54 3 21 09 87 6 54 32 10 9 87 65 43 2 10 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
str r1, [ r0, # GPEDS0 ]
pop { r0, r1 }
subs pc, lr, # 4
Obviamos los dos primeros pasos (apuntar a RTI e inicializacin de punteros de

pila) puesto que son idnticos al ejemplo anterior.
Lo siguiente que tenemos es configurar e inicializar los puertos del GPIO. Por
un lado ponemos los correspondientes a los LEDs rojos (GPIO 9 y GPIO 10) como
salida. Por otro lado escribimos un uno en ambos LEDs, para que al arrancar veamos
los dos LEDs encendidos. As sabemos que el programa est cargado a la espera de
que activemos los pulsadores:
ldr r0, = GPBASE
ldr r1, = 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0
Luego habilitamos las interrupciones particulares del GPIO en el puerto GPFEN0,

en concreto las que entran por los pulsadores (GPIO 2 y GPIO 3). Para que las
peticiones se propaguen desde el GPIO al controlador de interrupciones habilitamos
el bit 20 del puerto INTENIRQ2:

mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
ldr r0, = INTBASE
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Para terminar activando globalmente las IRQ y metindonos en el bucle infinito:

msr cpsr_c, r0
bucle : b bucle
Veamos ahora el aspecto que tiene la RTI. Lo primero es poner los LEDs sus-
ceptibles de encenderse (los LEDs rojos) a cero:
irq_handler :
push { r0, r1 }
ldr r0, = GPBASE
/* Apaga los dos LEDs rojos 5 43 21 0 98 76 54 3 21 09 87 6 54 32 10 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0
Testeamos cul de los dos pulsadores se ha activado, indicndolo en el flag Z:

/* Consulto si se ha pulsado el bot n GPIO2 */
ands r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
En funcin del flag Z encendemos uno u otro LED:

/* S : Activo GPIO 9 ; No : Activo GPIO 10 */
movne r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
moveq r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
Y finalmente desactivamos los dos flags GPIO pendientes de atencin:

mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
str r1, [ r0, # GPEDS0 ]
pop { r0, r1 }
subs pc, lr, # 4

5.1.9. Parpadeo secuencial de LEDs con sonido por altavoz

En este ejemplo vamos a trabajar con el temporizador, pero esta vez vamos a
complicar un poco las cosas. En lugar de una fuente vamos a atender simultnea-
mente las peticiones de los comparadores C1 y C3.
Con esta segunda fuente vamos a controlar el altavoz, como podemos observar en
la figura 5.9. Sacar un tono puro por el altavoz es equivalente a hacer parpadear un
LED, lo nico que cambia es que usamos otro pin distinto GPIO 4 y aumentamos la
frecuencia para que sea audible (a 1 Hz el odo humano no captara sonido alguno).
Utilizaremos la frecuencia estndar de afinacin de 440 Hz, que coincide con el tono
de espera de marcado en telefona fija.
Por otro lado en lugar de hacer parpadear todos los LEDs lo que haremos es
repetir una secuencia de 6 posiciones en la que en todo momento slo uno de los
6 LEDs est encendido, que va cambiando de izquierda a derecha (aparentando
movimiento) y cuando se llegue al sexto LED comenzamos de nuevo desde el primero.
Para dar ms sensacin de movimiento disminuimos el periodo a 200 milisegundos.
La clave de todo est en saber cul de los dos comparadores ha producido la
interrupcin (se puede dar el caso en que salten los dos a la vez). sto se puede
hacer de dos formas distintas: o bien leemos el bit asociado systim_cx en el puerto
IRQ pending 1, o bien leemos el Mx del puerto CS. Elegimos el segundo caso, as no
gastamos otro puerto ms para almacenar INTBASE.

El cdigo completo del ejemplo es el siguiente:

.text

msr cpsr_c, r0
mov sp, # 0x8000
msr cpsr_c, r0
mov sp, # 0x8000000
/* Configuro GPIOs 4, 9, 10, 11, 17, 22 y 27 como salida */

ldr r0, = GPBASE
ldr r1, = 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1
ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
/* Programo C1 y C3 para dentro de 2 microsegundos */

ldr r0, = STBASE
add r1, # 2
str r1, [ r0, # STC1 ]
str r1, [ r0, # STC3 ]

ldr r0, = INTBASE
mov r1, # 0b1010
msr cpsr_c, r0

bucle : b bucle


irq_handler :
push { r0, r1, r2, r3 }
/* Leo origen de la interrupci n */

ldr r0, = STBASE
ldr r1, = GPBASE
ldr r2, [ r0, # STCS ]
ands r2, # 0b0010
beq sonido
/* Si es C1, ejecuto secuencia de LEDs */

ldr r2, = cuenta
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
ldr r3, = 0 b 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0
str r3, [ r1, # GPCLR0 ] @ Apago todos los LEDs
ldr r3, [ r2 ] @ Leo variable cuenta
subs r3, # 1 @ Decremento
moveq r3, # 6 @ Si es 0, volver a 6
str r3, [ r2 ] @ Escribo cuenta
ldr r3, [ r2, + r3, LSL # 2 ] @ Leo secuencia
str r3, [ r1, # GPSET0 ] @ Escribo secuencia en LEDs

mov r3, # 0b0010
/* Programo siguiente interrupci n en 200ms */

ldr r2, = 200000 @ 5 Hz
add r3, r2
str r3, [ r0, # STC1 ]
/* Hay interrupci n pendiente en C3? */

ands r3, # 0b0100
beq final @ Si no, salgo
/* Si es C3, hago sonar el altavoz */

sonido : ldr r2, = bitson
ldr r3, [ r2 ]
eors r3, # 1 @ Invierto estado
str r3, [ r2 ]

mov r3, # 0b10000 @ GPIO 4 ( altavoz )

streq r3, [ r1, # GPSET0 ] @ Escribo en altavoz
strne r3, [ r1, # GPCLR0 ] @ Escribo en altavoz

mov r3, # 0b1000
/* Programo interrupci n para sonido de 440 Hz */

ldr r2, = 1136 @ Contador para 440 Hz
add r3, r2
str r3, [ r0, # STC3 ]

final : pop { r0, r1, r2, r3 }
subs pc, lr, # 4
bitson : .word 0 @ Bit 0 = Estado del altavoz

cuenta : .word 1 @ Entre 1 y 6, LED a encender
/* guia bits 7 65 4 3 2 1 09 8 7 6 5 43 2 1 0 9 87 6 5 4 3 21 0 */
secuen : .word 0b1000000000000000000000000000
.word 0b0000010000000000000000000000
.word 0b0000000000100000000000000000
.word 0b0000000000000000100000000000
.word 0b0000000000000000010000000000
.word 0b0000000000000000001000000000
Como es muy parecido al ejemplo de antes, slo vamos a comentar las diferencias
que encontremos. La primera de ellas es que adems de los 6 GPIOs de los LEDs,
configuramos como salida un sptimo pin, el GPIO 4, para manejar el altavoz:
ldr r0, = GPBASE
ldr r1, = 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
El siguiente cdigo es para incluir el comparador C3 (adems del C1 que haba an-
teriormente), tanto para proporcionar la primera interrupcin como para habilitarla
individualmente:
ldr r0, = STBASE
add r1, #2
str r1, [ r0, # STC1 ]
str r1, [ r0, # STC3 ]

ldr r0, = INTBASE

mov r1, # 0b1010
Ya hemos acabado con el programa principal, veamos ahora la RTI. Primero

mostramos la estructura del cdigo y luego las rutinas individuales tanto para el
manejo de LEDs como para el altavoz:
irq_handler :
push { r0, r1, r2, r3 }
ldr r0, = STBASE
ldr r1, = GPBASE
ands r2, # 0b0010
beq sonido
[ manejo de LEDs ]

ands r3, # 0b0100
beq final
sonido :
[ manejo de altavoz ]
final : pop { r0, r1, r2, r3 }

subs pc, lr, # 4
Los registros r0 y r1 los hacemos apuntar a la base del System Timer y del GPIO
y no tocamos dichos valores durante toda la interrupcin, vamos a estar constan-
temente leyendo y escribiendo puertos y resulta incmodo tener que cargar la base
cada vez.
Es un error muy habitual suponer que la fuente de la interrupcin slo ha sido
una, aunque la gran mayora de las veces sea as se puede dar el caso de que coincidan
los dos comparadores a la vez. De la misma forma si sabemos que slo hay dos fuentes
y una de ellas no ha provocado la interrupcin, por descarte ha tenido que ser la
otra, podemos ahorrarnos la comprobacin.
El flujo sera el siguiente: leemos M1 para ver si la interrupcin la ha provocado
el comparador de C1, si ha sido as ejecutamos el cdigo de manejo de LEDs; si no,
saltamos directamente al manejo del altavoz (sabemos seguro que la fuente viene de
ah).
Tras el cdigo del manejo de LEDs leemos M3 para saber si adems de C1 ha
saltado tambin el comparador C3. Si no ha saltado, lo ms normal, salimos por
final; si lo ha hecho, procesamos la interrupcin con el cdigo de manejo del altavoz

para luego salir de la RTI.

Estos programas no son fciles de crear y nunca funcionan a la primera. Es una
buena prctica hacer funcionar por separado el cdigo de los LEDs y el cdigo del
altavoz, y una vez comprobemos que funcionan, aglutinarlo en una nica RTI. De
esta forma aislamos lo mximo posible los errores que podamos cometer, es muy
fcil equivocarse en una tontera y estar dndole vueltas al cdigo sin encontrar el
fallo. A diferencia de los primeros captulos que disponamos de gdb, en Bare Metal
no tenemos acceso a ningn depurador.
Prosigamos ahora con el cdigo de manejo de LEDs. Recordemos que hemos com-
plicado un poco las cosas para emitir una secuencia en lugar de un simple parpadeo.
Para ello mostramos el cdigo seguido de las variables empleadas en el mismo:
ldr r2, = cuenta
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
ldr r3, = 0 b 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0
str r3, [ r1, # GPCLR0 ] @ Apago todos los LEDs
str r3, [ r2 ] @ Escribo cuenta
ldr r3, [ r2, + r3, LSL # 2 ] @ Leo secuencia # 2 ]
mov r3, # 0b0010
ldr r2, = 200000 @ 5 Hz
add r3, r2
str r3, [ r0, # STC1 ]
[ ... ]
/* guia bits 7 65 4 3 2 1 09 8 7 6 5 43 2 1 0 9 87 6 5 4 3 21 0 */
secuen : .word 0b1000000000000000000000000000
.word 0b0000010000000000000000000000
.word 0b0000000000100000000000000000
.word 0b0000000000000000100000000000
.word 0b0000000000000000010000000000
.word 0b0000000000000000001000000000
En la variable cuenta almacenamos un contador que va desde 6 hasta 1, que

actua como ndice para el array secuen. Al decrementar aprovechamos la propia
instruccin de resta para comprobar que se ha llegado al final de la cuenta (0),
y en dicho caso restablecemos la cuenta a 6 mediante la instruccin de ejecucin
condicional moveq.

En el array secuen tenemos almacenadas las posiciones que corresponden a los

LEDs dentro del puerto GPSET0, cada posicin del array es para encender un LED
en concreto. Antes de esto hemos apagado todos los LEDs enviando el valor que
codifica todos los LEDs al puerto GPCLR0.
A parte de sacar la secuencia correspondiente debemos especificar cundo ser la
siguiente interrupcin. Como hicimos en el ejemplo anterior, esto se resuelve leyendo
el valor del puerto STCLO, sumndole 200000 (200 milisegundos) y escribindolo en
el comparador STC1.
Acabado el cdigo de manejo de LEDs, ya slo falta por explicar el manejo del
altavoz:
sonido : ldr r2, = bitson
ldr r3, [ r2 ]
eors r3, #1 @ Invierto estado
str r3, [ r2 ]
streq r3, [ r1, # GPSET0 ] @ Escribo en altavoz
strne r3, [ r1, # GPCLR0 ] @ Escribo en altavoz
mov r3, # 0b1000
ldr r2, = 1136 @ Contador para 440 Hz
add r3, r2
str r3, [ r0, # STC3 ]
[ ... ]
bitson : .word 0
Es un calco de la rutina que haca parpadear todos los LEDs, cambiando el valor
que se envia a GPCLR0/GPSET0, el comparador que es C3 en lugar de C1, y el valor
que sumamos al temporizador, que se corresponde a 440 Hz en vez de a 1 Hz.
5.1.10. Manejo de FIQs y sonidos distintos para cada LED

Este ejemplo es muy parecido al anterior pero con cambios sutiles. El hecho de
cambiar una de las dos IRQs por una FIQ incluso simplifica el cdigo, ya que tienen
distintas RTIs y en cada una la fuente de interrupcin es nica, por lo que no hay
que comprobar nada ni hacer saltos.
Empecemos con el programa principal. Aqu s que hay cambios porque tenemos
que agregar un elemento nuevo al vector de interrupciones, inicializar el puntero de
pila del modo FIQ y activar la fuente de interrupcin FIQ local y globalmente:

Listado 5.6: Programa principal de inter5.s

/* Agrego vectores de interrupci n */
ADDEXC 0x1c, fiq_handler
/* Inicializo la pila en modos FIQ, IRQ y SVC */

mov r0, # 0b11010001 @ Modo FIQ, FIQ & IRQ desact
msr cpsr_c, r0
mov sp, # 0x4000
msr cpsr_c, r0
mov sp, # 0x8000
msr cpsr_c, r0
mov sp, # 0x8000000

ldr r0, = GPBASE
ldr r1, = 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1


ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
/* Programo C1 y C3 para dentro de 2 microsegundos */

ldr r0, = STBASE
add r1, # 2
str r1, [ r0, # STC1 ]
str r1, [ r0, # STC3 ]
/* Habilito C1 para IRQ */

ldr r0, = INTBASE
mov r1, # 0b0010
/* Habilito C3 para FIQ */

mov r1, # 0b10000011
str r1, [ r0, # INTFIQCON ]
/* Habilito interrupciones globalmente */

mov r0, # 0b00010011 @ Modo SVC, FIQ & IRQ activo
msr cpsr_c, r0

bucle : b bucle
Queremos que FIQ se active con C3, que es el bit 3 del IRQ 1, por tanto ndice 3
para la fuente FIQ. Como veis, la nica pega que tienen las FIQs es que slo admiten
una fuente de interrupcin. Adems del ndice ponemos el bit 7 a uno para indicar
que queremos habilitar dicha fuente, siendo la constante 0b10000011.
Ahora veamos el manejador IRQ (la RTI) que, como hemos adelantado, es ms
sencilla que en el ejemplo anterior:
/* Rutina de tratamiento de interrupci n IRQ */
irq_handler :
push { r0, r1, r2 }
ldr r0, = GPBASE
ldr r1, = cuenta
/* Apago todos LEDs 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */

ldr r2, = 0 b 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0


subs r2, #1 @ Decremento
moveq r2, #6 @ Si es 0, volver a 6
str r2, [ r1 ] , # - 4 @ Escribo cuenta

ldr r0, = STBASE
mov r2, # 0b0010
/* Programo siguiente interrupci n en 500ms */

ldr r1, = 500000 @ 2 Hz
add r2, r1
str r2, [ r0, # STC1 ]

pop { r0, r1, r2 }
subs pc, lr, # 4
Observamos que al acceder a la tabla secuen multiplicamos el ndice por 8 en

lugar de por 4. Esto es as porque hemos includo en dicha tabla el valor de la
longitud de onda (inverso de la frecuencia) con la que queremos que suene cada
LED, la zona de datos es sta:
bitson : .word 0 @ Bit 0 = Estado del altavoz
secuen : .word 0b1000000000000000000000000000
.word 716 @ Retardo para nota 6
.word 0b0000010000000000000000000000
/* guia bits 7 65 4 3 2 1 09 8 7 6 5 43 2 1 0 9 87 6 5 4 3 21 0 */
.word 0b0000000000100000000000000000
.word 0b0000000000000000100000000000
/* guia bits 7 65 4 3 2 1 09 8 7 6 5 43 2 1 0 9 87 6 5 4 3 21 0 */
.word 0b0000000000000000010000000000
.word 0b0000000000000000001000000000

Seran las notas puras que van despus del LA estndar de 440 Hz (1136), cuyos
semitonos se obtienen multiplicando la frecuencia por raz duodcima de 2, que es
aproximadamente 1,05946. Las notas seran, en hercios: LA (440), SI (493,88), DO
(523,25), RE (587,33), MI (659,26) y FA (698,46).
Finalmente tenemos el manejador de FIQ asociado al altavoz. La eleccin de la
fuente de interrupcin no es arbitraria, hemos escogido FIQ para el altavoz porque
se ejecutar ms veces que el cambio de LEDs, concretamente 220 veces ms con la
nota ms grave. En estos ejemplos no importa, pero en casos reales donde el tiempo
de CPU es un recurso limitado, los ciclos que nos ahorramos con una FIQ en un
proceso crtico pueden ser determinantes:
/* Rutina de tratamiento de interrupci n FIQ */
fiq_handler :
ldr r8, = GPBASE
ldr r9, = bitson
/* Hago sonar altavoz invirtiendo estado de bitson */

ldr r10, [ r9 ]
eors r10, # 1
str r10, [ r9 ] , # 4
/* Leo cuenta y luego elemento correspondiente en secuen */

ldr r10, [ r9 ]
ldr r9, [ r9, + r10, LSL # 3 ]
/* Pongo estado altavoz seg n variable bitson */


ldr r8, = STBASE
mov r10, # 0b1000
str r10, [ r8, # STCS ]
/* Programo retardo seg n valor le do en array */

add r10, r9
str r10, [ r8, # STC3 ]
/* Salgo de la RTI */
subs pc, lr, # 4

El cdigo sera idntico al de una IRQ si no fuera porque empleamos registros a

partir de r8 en lugar de a partir de r0, y no los salvaguardamos con las instrucciones
push/pop. La razn es que el modo de operacin FIQ es el nico que tiene sus propios
registros r8-r12 (ver figura 5.2) con el objetivo de no perder el tiempo guardando
y recuperando datos de la pila. En situaciones ms crticas podemos incluso ubicar
la RTI justo al final del vector de interrupciones. Esta tabla no contiene datos, sino
instrucciones, y lo que hace la CPU cuando ocurre una excepcin es saltar (ejecutar)
a la direccin asociada en dicho vector. As que cada elemento es una instruccin
de salto que apunta a su RTI correspondiente, de no ser un salto se solapara con
el siguiente elemento del vector. Excepto el ltimo elemento del vector, que no
se solapara con nada y que corresponde a las interrupciones FIQ. Se ha escogido
intencionalmente as para ahorrarse el salto inicial.
5.1.11. Control de luces/sonido con pulsadores en lugar tem-

porizadores
Los pulsadores izquierdo y derecho de nuestra placa externa estn asociados a los
puertos GPIO 2 y GPIO 3 respectivamente. Veremos cmo se genera una interrupcin
al pulsar cualquiera de los mismos.

El programa principal sera el siguiente:

Listado 5.7: Programa principal de inter6.s
/* Agrego vectores de interrupci n */
ADDEXC 0x1c, fiq_handler
/* Inicializo la pila en modos FIQ, IRQ y SVC */

mov r0, # 0b11010001 @ Modo FIQ, FIQ & IRQ desact
msr cpsr_c, r0
mov sp, # 0x4000
msr cpsr_c, r0
mov sp, # 0x8000
msr cpsr_c, r0
mov sp, # 0x8000000

ldr r0, = GPBASE
ldr r1, = 0 b 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1
ldr r1, = 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
/* Enciendo LEDs 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
/* Habilito pines GPIO 2 y 3 ( botones ) para interrupciones */

mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
/* Programo C1 para dentro de 2 microsegundos */

ldr r0, = STBASE
add r1, # 2
str r1, [ r0, # STC1 ]
/* Habilito GPIO para IRQ */

ldr r0, = INTBASE

/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* Habilito C1 para FIQ */

mov r1, # 0b10000001
str r1, [ r0, # INTFIQCON ]
/* Habilito interrupciones globalmente */

mov r0, # 0b00010011 @ modo SVC, FIQ & IRQ activo
msr cpsr_c, r0

bucle : b bucle
Lo nuevo que vemos aqu es una escritura en el puerto GPFEN0. De esta forma le
decimos al controlador de interrupciones que esos pines del GPIO sern los nicos
que provoquen interrupciones, concretamente flancos con de bajada sncronos (justo
en el momento en que el botn toca fondo).
El manejador FIQ es idntico al del ejemplo anterior, saca el sonido que corres-
ponde al LED por el altavoz, cambiando C3 por C1.
Lo ms relevante de este ejemplo est en la RTI asociada a la IRQ, que es la
siguiente:
irq_handler :
push { r0, r1, r2 }
ldr r0, = GPBASE
ldr r1, = cuenta
/* Apago todos LEDs 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */

ldr r2, = 0 b 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0
/* Leo bot n pulsado */

ands r2, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
beq incre
/* Si es bot n izquierdo, decrementar */

str r2, [ r0, # GPEDS0 ] @ Reseteo flag b. izq

b conti @ Salto a conti
/* Si es bot n derecho, incrementar */

incre : mov r2, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
str r2, [ r0, # GPEDS0 ] @ Reseteo flag b. der
add r2, # 1 @ Incremento
cmp r2, # 7 @ Comparo si llego a 7
/* Actualizo variable, enciendo LED y salgo */

conti : str r2, [ r1 ] , # - 4 @ Escribo variable cuenta
pop { r0, r1, r2 } @ Recupero registros
subs pc, lr, # 4 @ Salgo RTI
Tenemos una bifurcacin (saltos condicionales) debido a que cada botn es una
fuente distinta de interrupcin y tenemos que distinguir qu botn se ha pulsado.
Aqu por suerte tenemos un puerto totalmente anlogo al STCS de los temporizado-
res. Se llama GPEDS0 (tambin hay otro GPEDS1 para los GPIOs de 32 a 53 que no
necesitamos) y sirve tanto para saber qu fuente ha producido la interrupcin como
para resetear su estado (y as permitir volver a ser interrumpidos por el mismo pin
GPIO).
Con la instruccin ands comprobamos si un determinado bit est a 1 y lo indi-
camos en el flag Z. Tambin podra valer la instruccin tst, que tiene la ventaja de
no destruir el registro a la salida (de la misma forma que cmp es el equivalente no
destructivo de subs).
Y por ltimo debemos sacar la secuencia inversa a la que tenamos para que
al pulsar el botn izquierdo las luces vayan hacia la izquierda y que con el botn
derecho vayan en el otro sentido. Si la secuencia de izquierda a derecha era (6, 5, 4,
3, 2, 1, 6, 5, 4...), la inversa sera (1, 2, 3, 4, 5, 6, 1...). Es decir, incrementamos y
cuando llegamos a 7 lo convertimos en 1. sto se hace con el siguiente fragmento:
add r2, # 1 @ Incremento
cmp r2, # 7 @ Comparo si llego a 7
Ntese que aqu la opcin destructiva subs (en lugar de cmp) no nos vale porque
necesitamos el valor del registro despus. S que podemos cambiarlo por un teq (la
alternativa no destructiva de eors).

142 5.2. Ejercicios
5.2. Ejercicios
5.2.1. Todo con IRQs
Modifica el ltimo ejemplo (inter5.s) para controlar el altavoz tambin con
IRQs, prescindiendo totalmente de las interrupciones FIQs.
5.2.2. Alargar secuencia a 10 y parpadeo

Partiendo de inter5.s (o del resultado del ejercicio anterior) haz las siguientes
modificaciones. Si te resulta ms cmodo, realzalas por orden.
Sacar de la secuencia el LED 6 (el de ms a la derecha) y ponerlo a parpadear

continuamente con una cadencia de un segundo. En este momento tendrs que
acortar la secuencia a 5.
Duplica la secuencia a 10. Para ello utiliza el cdigo Morse aplicado a los dgitos
(todos tienen longitud 5). Cambia el punto (tono corto) por LED apagado y
el guin (tono largo) por LED encendido. Por supuesto los nuevos cdigos
tendrn su sonido asociado, sigue las notas (saltndote sostenidos y bemoles)
para completar la tabla.
5.2.3. Tope de secuencia y limitar sonido

Partiendo de inter5.s (o del resultado del ejercicio anterior) haz las siguientes
modificaciones. Si te resulta ms cmodo, realzalas por orden.
Hasta ahora si llegamos al lmite de la secuencia hemos comenzado por el

principio, haciendo que la secuencia sea circular tanto en un sentido como en
otro. Pues bien, ahora tienes que detectar dichos lmites (tanto superior como
inferior), poniendo una especie de tope al llegar al lmite, que impida avanzar
ms. En caso de intentar avanzar en el sentido prohibido al llegar a un tope, en
lugar de sacar el sonido que corresponda por el altavoz, aumntalo una escala
(tope superior) o disminyelo tambin una escala (tope inferior).
Como habrs observado el sonido continuo resulta un tanto molesto despus

de un tiempo. Y con la indicacin de los LEDs tenemos informacin suficiente
para saber en qu posicin de la secuencia estamos. Altera el programa para
que slamente suene el altavoz mientras el botn est pulsado, o lo que es lo
mismo, para el sonido del altavoz cuando detectes un flanco de bajada en la
seal GPIO correspondiente.

5.2.4. Reproductor de meloda sencilla
Escoge una meloda sencilla y trata de interpretarla. Emplea los LEDs a tu
gusto para que cambien segn la nota que est sonando. Implementa las siguientes
funciones en los pulsadores.
Pulsador izquierdo. Cambio de tempo. La meloda debe comenzar a tempo

normal (llammoslo 1), y variar desde tempo lento (0) y tempo rpido (2)
segn la secuencia (0, 1, 2, 0...) cada vez que pulsemos dicho botn.
Pulsador derecho. Iniciar/Parar/Reanudar. La meloda tiene una duracin

determinada y cuando acaba deja de sonar, no suena en modo bucle todo el
tiempo. Si pulsamos dicho botn cuando est en silencio despus que haya so-
nado la meloda, la funcin correspondiente sera la de iniciarla. Si lo pulsamos
durante la reproduccin actuara a modo de pause (los LEDs se quedan con-
gelados en el estado en el que estn), parando y reanudando la reproduccin
de la msica.
En este ejemplo puedes profundizar todo lo que quieras. Por ejemplo empieza
codificando los silencios, stos son muy importantes y tambin forman parte de
la meloda. Un segundo paso sera codificar la duracin de las notas, si no lo has
hecho ya. Tambin es posible tener varios instrumentos sonando a la vez, aunque
slo dispongamos de un altavoz, busca por internet 1-bit music o beeper music
si quieres saber cmo se hace.
Apndice A
Funcionamiento de la macro
ADDEXC
Contenido
A.1 Finalidad y tipos de salto . . . . . . . . . . . . . . . . . . . 145
A.2 Eleccin: salto corto . . . . . . . . . . . . . . . . . . . . . . 146
A.3 Escribir una macro . . . . . . . . . . . . . . . . . . . . . . . 146
A.4 Codificacin de la instruccin de salto . . . . . . . . . . . 147
A.5 Resultado . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
A.1. Finalidad y tipos de salto

Queremos implementar una macro que nos permita codificar las instrucciones
de salto dentro del vector de interrupciones. Como en la arquitectura el bus de
direcciones es de 32 bits no podemos codificar una instruccin de salto a cualquier
direccin con una instruccin de 32 bits, puesto que no nos queda espacio para el
cdigo de operacin.
Por esta razn existen dos tipos de salto, los saltos cortos (32M b) y los saltos
largos (todo el espacio de memoria). Un salto corto (aplicable tambin a saltos
condicionales) en ensamblador se escribira as.
b etiqueta
Los saltos largos no tienen instruccin propia, se realizan mediante la carga del
registro pc partiendo de un dato en memoria.
145
146 A.2. Eleccin: salto corto
ldr pc, a_etiq

[ ... ]
a_etiq : .word etiqueta
sto en cdigo mquina siempre se traduce a un direccionamiento relativo a pc,

si estuvisemos depurando veramos algo como esto.
ldr pc, [ pc, # 0x24 ]
Donde 0x24 es el desplazamiento (hemos elegido un valor arbitrario) donde se

encontrara a_etiq. De hecho esto mismo ocurre cuando utilizamos ldr con el ope-
rador =, podramos haber escrito esta otra instruccin con idntico resultado.
ldr pc, = etiqueta
Es la forma de escribirlo en alto nivel, se produce exactamente el mismo cdigo

mquina que en el caso anterior. Debemos recordar que las instrucciones donde
aparece el operador = ocupan 8 bytes, 4 para la propia instruccin y otros 4 para el
dato que generar de forma transparente el propio ensamblador.
A.2. Eleccin: salto corto

Si buscamos cdigo por internet lo ms normal es encontrar tablas de excepciones
completas que usan el salto largo en lugar del corto. Esto nos obliga a rellenar una
tabla en la que la mayor parte de vectores no se usan y a que dicha tabla sea esttica.
Por esa razn nosotros emplearemos nuestro propio mtodo basado en el salto corto.
Una desventaja es que tenemos que traducir una direccin (la de la RTI) al
cdigo mquina de un salto corto. Y la complicacin viene ms que nada porque el
salto corto es relativo, es decir, depende del valor que tenga pc en el momento del
salto.
La otra desventaja es que no podemos saltar ms all de 32Mb, pero para esto
tendramos que estar metidos en un proyecto bastante grande como para necesitar
ms de 32Mb de cdigo, y an as podemos solventarlo ubicando las RTI al principio.
A.3. Escribir una macro

En la primera lnea ponemos la directiva .macro seguida del nombre de la macro
ADDEXC y de los parmetros vector, dirRTI separados por coma.
Luego escribiramos el cdigo de la macro, indicando los parmetros con \vector

y \dirRTI para acabar con .endm.

Captulo A. Funcionamiento de la macro ADDEXC 147
A.4. Codificacin de la instruccin de salto

Como las instrucciones son de 32 bits y siempre estn alineadas a direcciones
mltiplos de 4, en lugar de codificar el desplazamiento en bytes se hace en nmero
de instrucciones (o grupos de 4 bytes). En cdigo mquina una instruccin de salto
incondicional tiene el formato indicado en la figura A.1.
Figura A.1: Formato de instruccin de salto
Los pasos para calcular la instruccin de salto seran.
Restar la direccin a saltar a la direccin actual
Dividir entre 4
Aadir 0xEA al byte alto
Como todo son constantes en teora podramos implementar la macro con dos
instrucciones. Desgraciadamente el preprocesador que usamos no es muy potente y si
un operando es una etiqueta slo nos permite operar con sumas y restas. No podemos
hacer las divisiones o desplazamientos que necesitamos, con lo que emplearemos una
tercera instruccin para hacer el desplazamiento.
La direccin actual es \vector, la de la RTI es \dirRTI y hay que restarle 8 por
el segmentado de la CPU (ver figura A.2).
instruccin = (\dirRT I \vector 8)/4 + 0xEA000000
instruccin = (\dirRT I \vector)/4 + 0xE9F F F F F E
instruccin = (\dirRT I \vector + 3A7F F F F F 8)/4
instruccin = (\dirRT I \vector + A7F F F F F B)ROR2
Vemos cmo en el ltimo paso hemos transformado una divisin en una rotacin,
donde los 2 bits menos significativos (ambos a 1) pasan a ser los ms significativos
tras la rotacin.

Figura A.2: Clculo del desplazamiento
A.5. Resultado
El cdigo final queda como sigue.
ROR r1, # 2
.endm
Como la arquitectura no nos permite escribir en una direccin absoluta, antes de

invocar la macro debemos asegurarnos de que r0 apunte al vector de interrupciones,
es decir que valga 0. En caso de usar esta macro como primera instruccin del progra-
ma Bare Metal podemos omitir la inicializacin de r0, ya que en las especificaciones
de carga del kernel.img se establece este valor.
Apndice B
Funcionamiento de la placa auxiliar
Contenido
B.1 Esquema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
B.2 Pinout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
B.3 Correspondencia . . . . . . . . . . . . . . . . . . . . . . . . 151
B.4 Funcionamiento . . . . . . . . . . . . . . . . . . . . . . . . . 152
B.5 Presupuesto . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
B.6 Diseo PCB . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Figura B.1: Placa auxiliar
149
150 B.1. Esquema
B.1. Esquema
Figura B.2: Esquema del circuito
Es un circuito sencillo y se puede montar en una protoboard sin problemas, el

esquema es el de la figura B.2. Se conecta en la fila inferior del conector GPIO,
dejando libre la superior para el puerto serie y otros propsitos.
B.2. Pinout
El puerto GPIO vara ligeramente dependiendo del modelo de Raspberry. En
nuestro caso la mayor diferencia est entre la revisin 1 y la 2, ya que el modelo B+
es compatible. Al ser idnticos los primeros 26 pines, cualquier perifrico diseado
para la revisin 2 es compatible con el modelo B+ (pero no al contrario).
La zona marcada con un recuadro verde (en la figura B.3) es donde conectaremos
nuestra placa auxiliar.

Captulo B. Funcionamiento de la placa auxiliar 151
Figura B.3: Pinout del puerto GPIO
B.3. Correspondencia
En la siguiente tabla vemos la correspondencia entre puertos del GPIO y com-
ponentes. Los componentes son: 2 pulsadores, 6 LEDs y un altavoz piezoelctrico.
Los nmeros marcados con asterisco tienen otra correspondencia en la revisin 1.
Nombre GPIO Tipo Descripcin

LED1 9 Salida Diodo led color rojo
LED2 10 Salida Diodo led color rojo
LED3 11 Salida Diodo led color amarillo
LED4 17 Salida Diodo led color amarillo
LED5 22 Salida Diodo led color verde
LED6 27* Salida Diodo led color verde
BOT1 2* Entrada Pulsador izquierdo
BOT2 3* Entrada Pulsador derecho
ALT 4 Salida Altavoz piezoelctrico
Tabla B.1: Correspondencia entre pines y componentes

152 B.4. Funcionamiento
B.4. Funcionamiento
Los LEDs son salidas que se activan (encienden) cuando escribimos un 1 en el
puerto correspondiente. Cuando estn a 0 permanecen apagados. Podemos jugar con
los tiempos de encendido/apagado para simular intensidades de luz intermedias.
El altavoz piezoelctrico es otra salida, conectada al puerto GPIO 4. A diferencia
de los LEDs no basta un 0 un 1 para activarlo, necesitamos enviar una onda
cuadrada al altavoz para que ste suene. Es decir, hay que cambiar rpidamente de
0 a 1 y viceversa, adems a una frecuencia que sea audible (entre 20 y 20000 Hz).
Por ltimo tenemos los pulsadores. Elctricamente son interruptores que conec-
tan el pin a masa cuando estn presionados. Cuando estn en reposo entran en
juego unas resistencias internas de la Raspberry (de pull-up) que anulan el compor-
tamiento de las de pull-up/pull-down que se cambian por software. De esta forma
los pulsadores envian un 0 lgico por el pin cuando estn pulsados y un 1 cuando
estn en reposo.
Los pulsadores y el LED verde de la derecha se corresponden con distintos puertos
segn el modelo de Raspberry. Podemos hacer que nuestro programa sea compatible
con todos los modelos, comprobando a la vez en las distintas entradas en el caso de
los pulsadores, o escribiendo a la vez en ambas salidas en el caso del LED verde.
En la figura B.4 tenemos la correspondencia entre pines, componentes y puertos
GPIO.
Figura B.4: Correspondencia LEDs y GPIO

B.5. Presupuesto
El presupuesto que mostramos a continuacin es haciendo un pedido de 30 uni-
dades, que son las necesarias para cubrir los puestos del laboratorio. En la tabla
ponemos el precio unitario, para que sea fcil extrapolar los datos a otras situacio-
nes. Cada puesto consta de un PC, con monitor, teclado y ratn conectado en una
red local y con Linux instalado.
Componente Tienda Precio

Raspberry Pi Modelo A+ RS Online 17,26
USB-Serie con DTR Ebay 1,44
PCB placa auxiliar Seeedstudio 0,20
Altavoz Ebay 0,08
Array resistencias Aliexpress 0,06
2 pulsadores Ebay 0,02
6 LEDs Ebay 0,17
Conector hembra Ebay 0,06
Total 19,29
Tabla B.2: Presupuesto unitario por puesto
En dicho presupuesto hemos incluido la Raspberry Pi, la placa auxiliar y el

conversor USB-Serie para comunicar el PC con la Raspberry.
B.6. Diseo PCB

El diseo de la PCB se ha hecho con la versin de evaluacin de la herramienta
Cadsoft EAGLE, disponible en http://www.cadsoftusa.com/download-eagle
Figura B.5: Diseo PCB del circuito
Apndice C
Cable serie y bootloaders
Contenido
C.1 Introduccin . . . . . . . . . . . . . . . . . . . . . . . . . . 155
C.2 Cable USB-serie desde el ordenador de desarrollo . . . . 155
C.3 Cable serie-serie que comunica dos Raspberries . . . . . 157
C.4 Reseteo automtico . . . . . . . . . . . . . . . . . . . . . . 159
C.5 Cdigo fuente del bootloader . . . . . . . . . . . . . . . . 162
C.1. Introduccin
En esta seccin profundizamos sobre dos mtodos para cargar programas en Bare
Metal sin necesidad de insertar y extraer continuamente la tarjeta SD. Existe un
tercer mtodo que no explicamos aqu, el del cable JTAG, pero pueden consultar los
archivos README del repositorio de David Welch[9].
Este apndice est basado en el contenido de dicho repositorio, y el cdigo fuente
del bootloader que mostramos aqu es idntico, el cual reproducimos con permiso
del autor.
C.2. Cable USB-serie desde el ordenador de desa-

rrollo
Con esta opcin hacemos todo el trabajo de ensamblado y enlazado en nuestro
ordenador de desarrollo, para luego transferir el archivo Bare Metal por el puerto
155
156 C.2. Cable USB-serie desde el ordenador de desarrollo
serie directamente a la Raspberry. Necesitamos un adaptador USB-serie como el de

la siguiente figura C.1.
Figura C.1: Cable USB-serie
Lo primero que tenemos que hacer es cargar el bootloader

https://github.com/dwelch67/raspberrypi/blob/master/bootloader05/kernel.img?raw=true
en la SD y alimentar la Raspberry. Es necesario resetear la Raspberry cada vez que
queramos cargar un programa Bare Metal nuevo, y esto se hace manualmente des-
enchufando y enchufando la alimentacin, o bien con el mtodo automtico que
explicamos en la ltima seccin.
Debemos conectar los 3 cables que van del adaptador USB-serie a la Raspberry,
con los pines tercero, cuarto y quinto de la fila superior del puerto GPIO. El tercer
pin es la masa, en el adaptador es un cable negro o marcado con GND en la seri-
grafa. El cuarto pin es GPIO 14 TXD, que se corresponde con el pin RXD en el
adaptador. Por ltimo el quinto pin es GPIO 15 RXD y va conectado al pin TXD
del adaptador. Ntese que los cables estn cruzados, el pin que transmite desde el
PC es el que recibe en la Raspberry y viceversa.
La primera vez que probemos el cable es recomendable probar con un programa

Captulo C. Cable serie y bootloaders 157
simple como un LED parpadeante, por ejemplo el ltimo esbn5.s del captulo 4. A
partir del cdigo fuente generamos el binario en Bare Metal, para lo cual necesitamos
el toolchain (cadena de herramientas) ARM, de la que usaremos el ensamblador as, el
enlazador ld y el copiador de secciones objcopy. A estas herramientas, que generan
binarios o ejecutables para una plataforma diferente a la de la mquina que realiza
la compilacin, se las denomina herramientas de compilacin cruzada.
En estos momentos tenemos el binario Bare Metal generado, llammoslo esbn5.img.
El siguiente paso es enviar este archivo por el puerto serie de forma que se ejecute
en la Raspberry. Pero no lo enviamos de cualquier manera, sino que emplearemos
un protocolo de transferencia que se llama XMODEM. Por suerte es uno de los
protocolos mejor soportados por los emuladores de terminal.
Dependiendo de nuestra plataforma hay distintos emuladores de terminal dispo-
nibles. Para Windows tenemos HyperTerminal o Tera Term, y en Linux tenemos
minicom, aunque para lo que queremos hacer (enviar un archivo) nos basta con el
comando sx.
Antes de nada hay que configurar los parmetros del puerto serie en el emulador
de terminal que estemos empleando. Los valores son: 8 bits de datos, sin paridad, 1
bit de parada, sin flujo de control y velocidad de transferencia de 115200 baudios.
Son todos parmetros por defecto excepto la velocidad, por lo que hay que asegurarse
de cambiar la velocidad antes de proceder a transferir el archivo.
Luego elegimos el protocolo, XMODEM, y le damos a transferir, seleccionando nues-
tro esbn5.img como archivo de origen. Si todo ha ido bien debera aparecer un men-
saje indicndolo en nuestro programa terminal y observaremos el LED parpadenado
en la Raspberry, prueba de que la transferencia ha sido exitosa.
En Linux es fcil automatizar este proceso con el comando sx, que es creando el
siguiente script enviar.
stty -F / dev / ttyUSB0 115200
sx $1 < / dev / ttyUSB0 > / dev / ttyUSB0
Y para enviar el archivo anterior con este script escribimos bajo lnea de coman-
dos lo siguiente.
. / enviar esbn5.img
C.3. Cable serie-serie que comunica dos Raspbe-

rries
Esta configuracin es ideal si queremos emplear una Raspberry como ordenador
de desarrollo. Aunque tambin est la alternativa de trabajar con un ordenador de
desarrollo aparte conectado a una de las Raspberries mediante ssh. La ventaja de

158 C.3. Cable serie-serie que comunica dos Raspberries
esta ltima alternativa es que podemos compilar desde la Raspberry sin necesidad
de tener instaladas las herramientas de compilacin cruzada en tu ordenador. Y
otra ventaja es que no necesitas estar fsicamente cerca de la Raspberry ni tener
enchufado el adaptador USB, te puedes conectar inalmbricamente a la Raspberry
mediante un router Wifi (con cable Ethernet entre el router y la Raspberry).
Lo primero es diferenciar las dos Raspberries. A una la llamamos Raspberry
de desarrollo, en la cual tendremos instalado Raspbian y es en la que trabajamos
directamente (con teclado y pantalla) o bien nos conectamos con ella mediante ssh.
A la otra la llamamos Raspberry Bare Metal, en la que sobreescribimos el kernel.img
de la SD con el mismo bootloader de antes. Es en esta Raspberry donde se ejecutan
los programas Bare Metal que vamos a desarrollar y por tanto donde enchufaremos
nuestra placa auxiliar.
La conexin entre ambas Raspberries se hace uniendo ambas masas y cruzando
los cables TXD y RXD de cada puerto serie, como viene indicado en la figura C.2.
Figura C.2: Dos raspberries en serie cruzado
Por defecto el puerto serie en Raspbian viene configurado como salida de consola.
Esta configuracin no nos interesa, se usa para diagnosticar errores mostrando por
un terminal los mensajes del arranque. Pero nosotros queremos usarlo como un

puerto serie genrico, para lo cual es necesario hacer los siguientes cambios.
En el archivo /etc/inittab descomentamos la lnea que empieza con T0:23...
y que hace mencin a la cadena ttyAMA0, y guardamos el archivo.
Luego en el archivo /boot/cmdline.txt buscamos los dos sitios (puede haber
uno slo) donde aparece ttyAMA0. Borramos los textos que hay entre espacios y que
incluyen el ttyAMA0, y despus guardamos.
Para comprobar que todo ha ido bien reseteamos la Rasbperry con sudo reboot
y tras el arranque escribimos.
cat / proc / cmdline
Comprobando que efectivamente no hay se hace ninguna referencia a ttyAMA0,

y luego escribimos este otro comando.
ps aux | grep ttyAMA0
Para verificar que el nico proceso que se lista en la salida es el del propio
comando ps y no existen otros.
Llegados a este punto ya tenemos el puerto serie disponible para nosotros. El
resto de pasos seran como en el caso anterior, pero cambiando la referencia que se
hace al puerto. Donde antes apareca /dev/ttyUSB0 (o algo similar) lo cambiamos
por /dev/ttyAMA0.
C.4. Reseteo automtico

Resulta tedioso tener que desenchufar y enchufar la Raspberry cada vez que
queremos introducir un nuevo programa Bare Metal. Una solucin intermedia es
soldar los dos pines de Reset que estn serigrafiados como P6 en la Raspberry 2.0
o como RUN en el modelo A+/B+. A stos pines le podemos conectar un pulsador,
con lo que simplificamos el reseteo, en lugar de desenchufar y enchufar pulsamos un
botn.
Sin embargo es muy conveniente buscar una solucin totalmente automtica,
mediante la cual el propio script que enva el archivo enve una seal de Reset
justo antes del envo. Para evitar confusiones, en lugar de montar los dos pines del
conector, montamos slo uno, el de la seal que provoca el Reset (el otro es la masa).
Viene sealada con un crculo rojo en la figura C.3.
De lo que se trata ahora es de enviar un pulso negativo a esa seal. En el caso
del cable USB-Serie lo haremos por una seal programable que no se emplea en el
enlace serie llamada DTR. En el caso de conexin serie-serie entre dos Raspberries
usaremos el pin GPIO 18 (justo a la derecha de RXD). Valdra cualquier otro pin,
pero por cercana empleamos este.

160 C.4. Reseteo automtico
Figura C.3: Seal de Reset donde montar el pin
Desgraciadamente con el cable USB-serie no podemos utilizar el comando sx, ya

que dichos comando sobreescribe el valor del pin DTR. El siguiente programa, adems
de enviar el pulso DTR para provocar el reset, trasfiere el archivo a la Raspberry. Con
esto ya no necesitaramos la herramienta sx.
Listado C.1: sendx.c
# include < termios .h >
# include < fcntl .h >
# include < stdlib .h >
# include < sys / ioctl .h >
int main ( int argc , char * argv []){

FILE * fi ;
int i , fd ;
unsigned char j , eot = 0 x04 , buf [132];
struct termios attr ;
buf [0]++;
buf [2] - -;
if ( argc != 2 )
printf ( " sendx v1 .00 by Antonio Villena , 21 Dec 2014\ n \ n "
" sendx < input_file >\ n \ n "
" < input_file > Bare Metal input binary file \ n \ n " ) ,
exit (0);

fi = fopen ( argv [1] , " r " );

if ( ! fi )
printf ( " Couldn t open file %s \ n " , argv [1]) ,
exit (1);
fd = open ( " / dev / ttyUSB0 " , O_RDWR | O_NOCTTY | O_NDELAY );
if ( fd == -1 )
printf ( " Couldn t open serial device / dev / ttyUSB0 \ n " ) ,
exit (1);
tcgetattr ( fd , & attr );
attr . c_cflag = B115200 | CS8 ;
attr . c_oflag = attr . c_iflag = attr . c_lflag = 0;
tcsetattr ( fd , TCSANOW , & attr );
i = TIOCM_DTR ;
ioctl ( fd , TIOCMSET , & i );
usleep ( 100*1000 );
i = 0;
ioctl ( fd , TIOCMSET , & i );
fcntl ( fd , F_SETFL , 0);
usleep ( 50*1000 );
tcflush ( fd , TCIOFLUSH );
read ( fd , &j , 1);
printf ( " Initializing file transfer ...\ n " );
while ( fread ( buf +3 , 1 , 128 , fi ) >0 ){
buf [1]++;
buf [2] - -;
for ( buf [131]= 0 , i = 3; i < 131; i ++ )
buf [131]+= buf [ i ];
if ( write ( fd , buf , 132) != 132 )
printf ( " Error writing to serial port \ n " ) ,
exit ( -1);
read ( fd , &j , 1);
if ( j == 6 ) // ACK
printf ( " . " ) ,
fflush ( stdout );
else
printf ( " Received %d , expected ACK \ n " , j ) ,
exit ( -1);
}
write ( fd , & eot , 1);
read ( fd , &j , 1);
if ( j != 6 ) // ACK
printf ( " No ACK for EOT message \ n " ) ,
exit ( -1);

162 C.5. Cdigo fuente del bootloader
printf ( " \ nFile transfer successfully .\ n " );

fclose ( fi );
close ( fd );
}
En el caso de las dos Raspberries instalamos primero el paquete wiringPi.

git clone git : // git.drogon.net / wiringPi
cd wiringPi
. / build
E inclumos el pulso reset mediante comandos, por ejemplo nuestro script que
compila y enva el archivo (todo en un paso) quedara as.
gpio export 18 out
as -o tmp.o $1
gpio export 18 in
ld -e 0 - Ttext = 0x8000 -o tmp.elf tmp.o
objcopy tmp.elf -O binary tmp.img
stty -F / dev / ttyAMA0 115200
sx tmp.img < / dev / ttyAMA0 > / dev / ttyAMA0
Observamos que el pulso de reset dura lo que tarde el programa en ensamblar,

duracin ms que suficiente como para provocar un Reset en la Raspberry Bare
Metal. Para llamar al script escribimos algo como esto.
. / compila esbn5.s
C.5. Cdigo fuente del bootloader

Mostramos la parte principal del programa bootloader, el resto de archivos estn
en el repositorio.
Listado C.2: bootloader05.c
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
unsigned char xstring [256];
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int notmain ( void )
{
unsigned int ra ;
unsigned int rx ;
unsigned int addr ;
unsigned int block ;
unsigned int state ;

unsigned int crc ;
uart_init ();
hexstring (0 x12345678 );
hexstring ( GETPC ());
hexstring ( ARMBASE );
timer_init ();
// SOH 0 x01
// ACK 0 x06
// NAK 0 x15
// EOT 0 x04
// block numbers start with 1
// 132 byte packet

// starts with SOH
// block number byte
// 255 - block number
// 128 bytes of data
// checksum byte ( whole packet )
// a single EOT instead of SOH when done , send an ACK on it too
block =1;
addr = ARMBASE ;
state =0;
crc =0;
rx = timer_tick ();
while (1)
{
ra = timer_tick ();
if (( ra - rx ) >=4000000)
{
uart_send (0 x15 );
rx +=4000000;
}
if (( uart_lcr ()&0 x01 )==0) continue ;
xstring [ state ]= uart_recv ();
rx = timer_tick ();
if ( state ==0)
{
if ( xstring [ state ]==0 x04 )

{
uart_send (0 x06 );
for ( ra =0; ra <30; ra ++) hexstring ( ra );
uart_flush ();
BRANCHTO ( ARMBASE );
break ;
}
}
switch ( state )
{
case 0:
{
if ( xstring [ state ]==0 x01 )
{
crc = xstring [ state ];
state ++;
}
else
{
// state =0;
uart_send (0 x15 );
}
break ;
}
case 1:
{
if ( xstring [ state ]== block )
{
crc += xstring [ state ];
state ++;
}
else
{
state =0;
uart_send (0 x15 );
}
break ;
}
case 2:
{

if ( xstring [ state ]==(0 xFF - xstring [ state -1]))

{
state ++;
}
else
{
uart_send (0 x15 );
state =0;
}
break ;
}
case 131:
{
crc &=0 xFF ;
if ( xstring [ state ]== crc )
{
for ( ra =0; ra <128; ra ++)
{
PUT8 ( addr ++ , xstring [ ra +3]);
}
uart_send (0 x06 );
block =( block +1)&0 xFF ;
}
else
{
uart_send (0 x15 );
}
state =0;
break ;
}
default :
{
state ++;
break ;
}
}
}
return (0);
}

Al comienzo se envan tres cadenas en hexadecimal por el puerto (0x12345678,

GETPC() y ARMBASE) para indicar que el bootloader est listo para recibir. Esto
lo podemos ver si empleamos un programa terminal como minicom para leer del
puerto.
Despus se inicializan algunas variables y nos metemos en el bucle principal.
Se supone que el primer byte que tenemos que recibir desde el host es SOH, en
hexadecimal es 0x01. Si pasado un tiempo no recibimos nada, enviamos un NAK
(0x15) para indicarle al host que estamos vivos. En realidad este comando sirve
para decirle al host que el paquete recibido es errneo, que nos lo enve nuevamente.
El host enviar a la Raspberry el archivo en trozos de 128 bytes cada uno (relle-
nando el ltimo trozo con ceros hasta que ocupe 128 bytes) con este formato.
Figura C.4: Formato de paquete XMODEM
Se trata del byte SOH seguido del nmero de bloque, luego tenemos otra vez el
nmero de bloque pero complementado, a continuacin los 128 bytes de datos para
acabar con un ltimo byte de suma de comprobacin. Este ltimo byte es la suma de
todos los anteriores, quedndonos con los 8 bits menos significativos del resultado.
Entonces la Raspberry lleva la cuenta del byte por el que vamos dentro de dicho
paquete a partir de switch(state). De tal forma que si state vale 0, lo que espe-
ramos es SOH o EOT, cualquier otro valor indica que algo va mal por tanto enviamos
un NAK al host y ponemos state a cero.
Para los estados 1 y 2 simplemente comprobamos que el byte recibido coincide
con el nmero de bloque, y reportamos error en caso contrario de la misma forma
que antes (enviando NAK y state=0).
Luego tenemos los estados que van entre 3 y 131, en los que vamos escribiendo
el fichero en memoria e incrementando el puntero, a la vez que vamos calculando el
byte de suma para la comprobacin.
Por ltimo tenemos el estado 131, en el cual ya hemos recibido los bytes de
datos y lo que leemos ahora es el byte de suma de comprobacin. Comparamos que
coincide con el valor esperado, respondiendo con ACK, o notificamos del error como
siempre (con NAK y state=0).
En cuanto el host recibe el ACK del ltimo paquete enviado, ste en lugar de
enviar de nuevo un paquete completo, enva un slo byte, EOT, para indicar a la
Raspberry que ya no quedan ms paquetes por enviar y se acaba la transmisin.
Esta situacin la comprueba la Raspberry al principio de cada paquete, de tal
forma que si recimibos un EOT del host damos por acabada la transmisin y ejecu-

tamos el archivo Bare Metal ledo con BRANCHTO, que en bajo nivel se corresponde
con saltar a 0x8000.
En la figura C.5 tenemos un ejemplo completo de transmisin. En l se envan 4
paquetes, con errores y reenvos en los paquetes 2 y 3. Podra tratarse de un archivo
que ocupase 500 bytes, y que la utilidad sx haya rellenado en el ltimo paquete 12
bytes con ceros, para que de esta forma todos los paquetes ocupen 128 bytes (la
parte til, contando cabeceras y dems cada paquete ocupa 132 bytes).
Figura C.5: Ejemplo de transmisin

Apndice D
Resistencias programables de pull-up

y pull-down
Contenido
D.1 Introduccin . . . . . . . . . . . . . . . . . . . . . . . . . . 169
D.2 Pulsadores en la placa auxiliar . . . . . . . . . . . . . . . 170
D.3 Ejemplo de aplicacin . . . . . . . . . . . . . . . . . . . . . 170
D.3.1 Pulsador a masa sin cambiar configuracin . . . . . . . . . 170
D.3.2 Pulsador a masa cambiando configuracin . . . . . . . . . 172
D.3.3 Pulsador a Vcc sin cambiar configuracin . . . . . . . . . 175
D.1. Introduccin
En general las resistencias de pull-up y pull-down son resistencias que se ponen
en las entradas para fijar la tensin que de otra forma quedara indeterminada, al
estar en situacin de circuito abierto o alta impedancia. El ejemplo tpico donde se
usa es en un pulsador. Elctricamente un pulsador no es ms que un interruptor
que deja pasar la corriente cuando est pulsado y se queda en circuito abierto en su
posicin de reposo (sin pulsar). De los dos contactos que tiene, uno se conecta a masa
y el otro al pin de entrada de la Raspberry. As que cuando lo pulsamos hacemos
un corto que llevara los cero voltios de la masa al pin de entrada (enviamos un cero
lgico), pero cuando est sin pulsar no enviamos nada al pin, ste se queda en lo
que se denomina alta impedancia.
Todos los pines del GPIO en la Raspberry se pueden configurar por software
para que se comporten como queramos: o bien sin resistencia, o con una resistencia
169
170 D.2. Pulsadores en la placa auxiliar
a Vcc (pull-up) o con una resistencia a masa (pull-down). Este tipo de resistencias
son dbiles (weak) debido a que estn dentro de la pastilla (SoC) y se implementan
con transistores. Se puede anular el efecto de estas resistencias poniendo resistencias
externas.
D.2. Pulsadores en la placa auxiliar

En la placa auxiliar tenemos dos pulsadores conectados a GPIO 2 y GPIO 3. No
es casualidad que estn conectados concretamente a esos dos pines. Son los nicos
pines que tienen resistencias externas de pull-up, concretamente de 1K8, que anulan
cualquier configuracin interna que pongamos. La razn es porque las resistencias
internas son dbiles, tienen un valor aproximado de unos 50K. Cuando hay dos
resistencias en paralelo como es el caso, la de menor valor anula el efecto de la de
mayor valor.
Por tanto si configuramos GPIO 2 GPIO 3 como entradas, independientemen-
te del valor que configuremos por software, se comportarn siempre como si slo
tuviesen una resistencia de pull-up.
El propsito de este apndice es aprender a cambiar la configuracin de los
pull-ups/pull-downs en caso de usar otras placas auxiliares distintas. En la nuestra
las nicas entradas (pulsadores) que hay estn resueltas con las resistencias antes
comentadas que tiene la Raspberry slo en esos dos pines.
D.3. Ejemplo de aplicacin

El montaje que proponemos es con uno de los pines de la fila superior, en concreto
el pin GPIO 18 que hay a la derecha de los pines del puerto serie. En estos ejemplos
no vamos a requerir la placa auxiliar, de esta forma dejamos libres los pines Vcc
(3.3V), ya que necesitaremos uno para el ltimo ejemplo.
D.3.1. Pulsador a masa sin cambiar configuracin

En este primer ejemplo vamos a tratar de encender el LED interno de la Rasp-
berry llamado ACT (OK) mediante un pulsador externo. El primer montaje sera el
de la figura. El esquema sera el de la figura D.1.
Ahora escribimos el cdigo. Como el pin GPIO que controla dicho LED es distinto
en los modelos normales que en los A+/B+, enviamos la seal a ambos pines. En el
modelo normal sera GPIO 16 y en el plus, el GPIO 47.

Captulo D. Resistencias programables de pull-up y pull-down 171
Figura D.1: Pulsador a masa
Listado D.1: apend1.s

.text
ldr r0, = GPBASE
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r2, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 */
mov r3, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
bucle : str r2, [ r0, # GPCLR0 ] @ apago GPIO 16
str r3, [ r0, # GPCLR1 ] @ apago GPIO 47

172 D.3. Ejemplo de aplicacin
ldr r1, [ r0, # GPLEV0 ]

/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
tst r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
streq r2, [ r0, # GPSET0 ] @ enciendo GPIO 16
b bucle
Probamos el cdigo y comprobamos que al pulsar el botn izquierdo no pasa

nada, el LED est siempre encendido.
Esto se debe a que por defecto el pin GPIO 18 est configurando con una resis-
tencia de pull-down y nosotros necesitamos una de pull-up, de lo contrario siempre
leeremos un cero por dicho pin. Los valores por defecto (tras el reset) se pueden con-
sultar en la pgina 103 del datasheet, aunque la mayor parte de los pines disponibles
por el puerto estan a pull-down.
Para solventar sto hay tres opciones: o conectar el otro terminal del interruptor
a Vcc en lugar de a GND, o configurar el pin para cambiarlo de pull-down a pull-up,
o conectar una resistencia externa a Vcc que anule el pull-down interno. Nosotros
vamos a explorar las dos primeras opciones.
D.3.2. Pulsador a masa cambiando configuracin

En este ejemplo vamos a configurar GPIO 18 a pull-up de acuerdo a la siguiente
figura D.2.
Para configurar un pin determinado en pull-up/pull-down/desconectado segui-
mos los siguientes pasos.
1. Escribir en GPPUD el tipo de resistencia que queremos. Un 0 sera si no queremos

resistencia, un 1 si es de pull-down un 2 si lo que queremos es un pull-ups.
2. Esperar 150 ciclos. Esto provee el tiempo requerido de set-up para controlar
la seal.
3. Escribir en GPPUDCLK0/1 un 1 en la posicin de los pines que queramos modi-

ficar, mientras que los que estn a 0 mantendrn su antiguo estado.
4. Esperar otros 150 ciclos. Con esto le damos tiempo de hold suficiente a la
seal.
5. Poner GPPUD en su estado de reposo, que sera a valor 0 (desactivado).
6. Escribir un 0 en GPPUDCLK0/1.

Figura D.2: Resistencia interna de pull-up
Una de las cosas que tenemos que hacer es esperar 150 ciclos (como mnimo).
Como sabemos que un salto condicional tarda al menos dos ciclos en ejecutarse,
nuestra rutina de retardo sera la siguiente.
wait : mov r1, # 50
wait1 : subs r1, # 1
bne wait1
bx lr
Y el cdigo que hace todo lo anterior, para poner a pull-up el GPIO 18 (donde
hemos puesto el pulsador) es el siguiente.
str r1, [ r0, # GPPUD ]
bl wait
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
str r1, [ r0, # GPPUDCLK0 ]
bl wait
mov r1, # 0

174 D.3. Ejemplo de aplicacin
El ejemplo completo quedara as.

.text
ldr r0, = GPBASE
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
mov r1, # 2
bl wait
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
bl wait
mov r1, # 0
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r2, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 */
mov r3, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
tst r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
b bucle
wait : mov r1, # 50

wait1 : subs r1, # 1
bne wait1
bx lr
Comprobamos cmo ahora s funciona, y mientras tenemos el botn presionado,

el LED se enciende, apagndose en cuanto lo soltamos.

D.3.3. Pulsador a Vcc sin cambiar configuracin

Cambiamos el montaje, y en lugar de a GND conectamos el pulsador a Vcc segn
la figura D.3.
Figura D.3: Pulsador a Vcc
De esta forma aprovechamos que ese pin en concreto est conectado a pull-down
tras el reset, por lo que no habra que cambiar la configuracin del pin para obtener
lo que vemos en la figura D.4.
Prcticamente tendramos el mismo cdigo que en apend1.s no nos funcionaba,
la nica diferencia es que cambiamos los streq por strne.
.text
ldr r0, = GPBASE
/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

/* guia bits x x 9 9 9 8 8 8 7 7 7 6 6 6 5 5 5 4 4 4 3 3 3 2 2 2 1 1 1 0 0 0 */
mov r1, # 0 b 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
mov r2, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 */
mov r3, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
/* guia bits 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 */
tst r1, # 0 b 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
strne r2, [ r0, # GPSET0 ] @ enciendo GPIO 16
strne r3, [ r0, # GPSET1 ] @ enciendo GPIO 47
b bucle
Figura D.4: Resistencia interna de pull-down

Bibliografa
[1] David Thomas. Introduccin al arm. http://thinkingeek.com/2013/01/09/

arm-assembler-raspberry-pi-chapter-1/, 2012.
[2] rferrer de THINK IN GEEK. Tutorial de asm para raspberry pi. http://
thinkingeek.com/2013/01/09/arm-assembler-raspberry-pi-chapter-1/,
2013-2014.
[3] Alex Chadwick. Baking pi - desarrollo de sistemas operativos. http://www.

cl.cam.ac.uk/projects/raspberrypi/tutorials/os/index.html, 2013.
[4] Broadcom Corporation. Bcm2835 arm peripherals. http://www.raspberrypi.

org/wp-content/uploads/2012/02/BCM2835-ARM-Peripherals.pdf, 2012.
[5] Qemu - emulating raspberry pi the easy way (linux or windows!). http://
xecdesign.com/qemu-emulating-raspberry-pi-the-easy-way, 2012.
[6] ARM Limited. Arm1176jzf technical reference manual. http:

//infocenter.arm.com/help/topic/com.arm.doc.ddi0301h/DDI0301H_
arm1176jzfs_r0p7_trm.pdf, 2004-2009.
[7] Documentacin gdb. https://sourceware.org/gdb/current/onlinedocs/

gdb/, 1998-2014.
[8] Wikipedia. Formato elf. http://es.wikipedia.org/wiki/Executable_and_

Linkable_Format, 2013.
[9] David Welch. Repositorio de david welch. https://github.com/dwelch67/

raspberrypi, 2012-2014.
[10] Gerardo Bandera Burgueo, Maria ngeles Gonzlez Navarro, Eladio D. Guti-
rrez Carrasco, Julin Ramos Czar, Sergio Romero Montiel, Maria Antonia Tre-
nas Castro, and Julio Villalba Moreno. Prcticas de Estructura de Computado-
res. Universidad de Mlaga, 2002.
177
[11] Embedded Linux Wiki. Gpio y otros perifricos a bajo nivel. http://elinux.
org/RPi_Low-level_peripherals, 2012-2014.
[12] Ignacio Moreno Doblas. Plantilla de pfc/tfg/tfm en latex, 2014.

LibroDePracticas PDF

Cargado por

Copyright:

Formatos disponibles

LibroDePracticas PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

LibroDePracticas PDF

Cargado por

Copyright:

Formatos disponibles

ANTONIO JOS VILLENA GODOY

RAFAEL ASENJO PLAZA

Departamento de Arquitectura de Computadores

UNIVERSIDAD DE MLAGA / MANUALES

Este material ha sido preparado por:

c Esta obra est bajo una Licencia Creative Commons Atribucin-NoComercial-

b Debe dar crdito en la obra en la forma especificada por el autor o

e El licenciante permite copiar, distribuir y comunicar publicamente la

d El licenciante permite copiar, distribuir, transmitir y comunicar pbli-

Si desea enviar sugerencias, comentarios o propuestas de mejora sobre el con-

AAPCS ARM Architecture Procedure Call Standard

ARM Advanced RISC Machines

CPSR Current Program Status Register

CPU Central Processing Unit

CHI system timer Counter HIgher

CLO system timer Counter LOwer

CS system timer Control/Status

ETSII Escuela Tcnica Superior de Ingeniera Informtica

FIQ Fast Interrupt reQuest

GNU GNU is Not Unix

GCC GNU C Compiler

GDB GNU DeBugger

GPAFEN GPIO Pin Async. Falling Edge Detect

GPAREN GPIO Pin Async. Rising Edge Detect

GPEDS GPIO Pin Event Detect Status

GPFEN GPIO Pin Falling Edge Detect Enable

GPHEN GPIO Pin High Detect Enable

GPIO General-Purpose Input/Output

2 Tipos de datos y sentencias de alto nivel 31

3 Subrutinas y paso de parmetros 55

4 E/S a bajo nivel 83

5 Interrupciones hardware 103

A Funcionamiento de la macro ADDEXC 145

B Funcionamiento de la placa auxiliar 149

C Cable serie y bootloaders 155

D Resistencias programables de pull-up y pull-down 169

1.1 Registros de la arquitectura ARM . . . . . . . . . . . . . . . . . . . . 3

2.1 Representacin de un vector en memoria . . . . . . . . . . . . . . . . 38

3.1 Uso de la pila en una funcin . . . . . . . . . . . . . . . . . . . . . . 65

4.1 Funcionamiento de una llamada a printf . . . . . . . . . . . . . . . . 85

5.1 Registro cpsr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

A.1 Formato de instruccin de salto . . . . . . . . . . . . . . . . . . . . . 147

B.1 Placa auxiliar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

C.1 Cable USB-serie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

D.1 Pulsador a masa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

1.1 Lista de familias y arquitecturas ARM . . . . . . . . . . . . . . . . . 2

5.1 Vector de interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . 105

B.1 Correspondencia entre pines y componentes . . . . . . . . . . . . . . 151

El minicomputador Raspberry Pi es una placa del tamao de una tarjeta de

Tecnologa de Computadores: Asignatura obligatoria del mdulo de Formacin

Comn de las titulaciones de Grado en Ingeniera Informtica, Grado en Inge-

Estructura de Computadores: Asignatura obligatoria del mdulo de Forma-

Sistemas Operativos: Asignatura obligatoria del mdulo de Formacin Comn

Diseo de Sistemas Operativos: Asignatura obligatoria del mdulo de Tecno-

En esas cuatro asignaturas, uno de los conceptos ms bsicos es el de gestin

bajo nivel en el captulo 4 y las interrupciones en el captulo 5. En los apndices

Objetivo: En esta sesin vamos a conocer el entorno de trabajo. Veremos qu

1.1. Lectura previa

Familia Arquitectura Bits Ejemplos de dispositivos