# data[].attributes.body
ARM es una arquitectura RISC (Reduced Instruction Set Computer - Ordenador con Conjunto Reducido de Instrucciones) de 32 bits, salvo la versión del core ARMv8-A que es es mixta 32/64 bits (bus de 32 bits con registros de 64 bits).

Se trata de una arquitectura licenciable, lo que quiere decir que la empresa desarrolladora ARM Holdings diseña la arquitectura,  pero son otras compañías las que fabrican y venden chips.

# data[].attributes.body
La arquitectura ARMv6 presenta un grupo de 17 registros de 32 bits cada uno.

Registros Generales

El propósito de estos es el almacenamiento temporal de datos.

Registros Especiales

SP/R13. Stack Pointer o Puntero de Pila.

LR/R14. Link Register o Registro de Enlace

PC/R15. Program Counter o Contador de Programa.

Registros CPSR

En estos registros se almacenan banderas condicionales y bits de control.

# data[].attributes.body
El ensamblador es un lenguaje de bajo nivel que permite un control directo de la CPU y todos los elementos asociados.

Desarrollar programas en lenguaje ensamblador es un proceso laborioso. Pues cada línea de un programa ensamblador consta de una instrucción del procesador y la posición que ocupan los datos de esa instrucción.

# data[].attributes.headline
Ventajas y Desventajas de Lenguaje Ensamblador

# data[].attributes.subject
Ventajas y Desventajas de Lenguaje Ensamblador

# data[].attributes.body
Ventajas

Presenta como principal característica la flexibilidad y la posibilidad de acceso directo a nivel de registro.

Desventajas

Programar en ensamblador es laborioso puesto que los programas contienen un número elevado de líneasl.

# data[].attributes.body
Los pasos habituales para hacer un programa son los siguientes:

1. Escribir el programa en el lenguaje fuente.

2. Traducirlo a lenguaje máquina, hay que utilizar un programa traductor.

3. Un fichero ejecutable contiene el programa traducido más una serie de códigos que debe tener todo programa que vaya a ser ejecutado en una máquina determinada.

4. El encargado de unir todo es un programa llamado linker que genera el programa ejecutable.

El traductor/ensamblador, linker y debugger son respectivamente GNU Assembler (as), GNU Compiler Collection (gcc) y GNU Debugger (gdb).

# data[].attributes.body
En el código hay una serie de elementos que aparecerán en todos los programas, se adjunta una imagen de ejemplo en el bloque. La estructura más general de un módulo fuente es:

Sección de datos. Viene identificada por la directiva .data. En esta zona se definen todas las variables que utiliza el programa.

Sección de código. Se indica con la directiva .text, y sólo puede contener código o datos no modificables.

De estas dos secciones la única que obligatoriamente debe existir es la sección .text (o sección de código).

# data[].attributes.body
Las instrucciones son representaciones mnemotécnicas del juego de instrucciones del procesador.

Etiqueta : Mnemónico Operando / s /* Comentario */

Ejemplo:

main : ldr r1, puntero_var1 /* r1 <- & var1 */

Etiqueta, si aparece, debe estar formado por una cadena alfanumérica.

Mnemónico. Está formado por caracteres alfabéticos (entre 1 y 11 caracteres).

Operando/s indica dónde se encuentran los datos. Puede haber 0, 1 o más operandos en una instrucción.

Comentario es opcional  y debe comenzar con la secuencia /* y acabar con */ .

# data[].attributes.body
Para representar números tenemos 4 bases.

Base Decimal, no lleva ningún delimitador especial.

Base Hexadecimal, que indicaremos con el prefijo 0x.

Base Binaria, que emplea el prefijo 0b antes del número en binario.

Base Octal, que usaremos en raras ocasiones y se especifica con el prefijo 0.

Para representar caracteres y cadenas emplearemos las comillas simples y las comillas dobles respectivamente.

# data[].attributes.body
Se pueden ubicar tanto en la sección de datos como en la de código.  En la zona de datos, las etiquetas pueden representar variables, constantes y cadenas. En la zona de código podemos usar etiquetas de salto, funciones y punteros a zona de datos.

# data[].attributes.body
Podemos agrupar el conjunto de instrucciones del as, según el tipo de función que realice el microprocesador:

Instrucciones de Transferencia de Datos.

Instrucciones Aritméticas.

Instrucciones de Manejo de Bits.

Instrucciones de Transferencia de Control.

# data[].attributes.headline
Configuración del Entorno Para Prácticas en Casa

# data[].attributes.subject
Configuración del Entorno Para Prácticas en Casa

# data[].attributes.body
Para configurar el entorno en Windows se siguen los siguientes pasos:

1. Descargamos la última versión 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 versión será más moderna.

3. Descargamos el emulador QEMU desde aquí:

http://lassauge.free.fr/qemu/

4. Descargamos el siguiente núcleo o kernel desde aquí:

http://xecdesign.com/downloads/linux-qemu/kernel-qemu

5. Lanzamos la línea de comandos o ventana de MS-DOS. Esto se hace desde

Programas->Accesorios->Símbolo 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. Una vez se muestran los mensajes de arranque aparece el siguiente texto:

raspberrypi login :

Nosotros escribimos pi.

5. Luego nos piden el password, que es raspberry.

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 línea:

#/ 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 terminado.

# data[].attributes.headline
Tipos de Errores en la Creación de un Programa

# data[].attributes.subject
Tipos de Errores en la Creación de un Programa

# data[].attributes.body
Hay dos tipos de errores: los sintácticos o detectables en tiempo de traducción y los errores semánticos o detectables en tiempo de ejecución.

Errores sintácticos. Por ejemplo, escribir mal una instrucción o hacer una operación entre dos tipos de datos incompatibles.

Errores semánticos. Todas las instrucciones pueden ser correctas, pero se puede haber olvidado poner la condición de salida de un bucle (y que no termine nunca) o que sencillamente el programa no haga lo que queremos.

# data[].attributes.body
Se realiza con el programa Gnu Assembler, con el siguiente comando:

as -o nombreprograma.o nombreprograma.s

El as genera un fichero nombreprograma.o. Para montar (linkar) hay que hacer:

gcc -o nombreprograma nombreprograma.o

Una vez hecho ésto, ya tenemos un fichero ejecutable (nombreprograma) que podemos ejecutar o depurar con el gdb.

NOTA: Los comandos y nombres son sensibles a las mayúsculas.

# data[].attributes.body
Las directivas más frecuentes en el as son:

Directivas de asignación.

Directivas de control.

Directivas de operando.

Directivas de Macros.