/*
  Este programa corresponde al propuesto en el entregable I1. Está
  programado para la arquitectura Thumb de ARM y para ejecutarse en el
  simulador QtARMSim ─a partir de la versión 0.3.7─. La única diferencia
  que presenta con un caso real es que, al no incluir el simulador
  ningún dispositivo de entrada, ésta se simula leyendo el valor de la
  altura de una cadena de texto que representa dicho número escrito en
  decimal ─como lo iría tecleando un usuario─.

  Hay que mencionar también que, dado que la arquitectura no soporta
  números reales, se utiliza la coma fija para trabajar, por lo que los
  valores se mantienen multiplicados por 100, lo que equivale a trabajar
  siempre con dos cifras decimales. Esto presenta el pequeño
  inconveniente de que los cálculos siempre truncan el resultado a estas
  dos cifras, sin redondear. De ahí la pequeña diferencia con el
  resultado del entregable, 22,15, que en esta versión es 22,14. Para 
  imprimir correctamente el resultado sí se usarán operaciones con 
  números reales -mediante funciones del firmware- y la función printf.

  El programa guarda en memoria las constantes ─los textos y el valor de
  g─ y solamente dos variables: el valor numérico de la altura leída y
  la velocidad final. Todas las variables intermedias se guardan en
  registros. La salida de datos se realiza en el display simulado y la
  entrada, como se ha dicho, se simula mediante una cadena de texto que
  representa el número tecleado en decimal.
*/


	.data

@ Variables. Espacio mara mantener la altura leída y la velocidad
@ final. Las variables intermedias estarán en registros.
h_leida:.space 4
vel:	.space 4

@ Constantes. Valor de g (multiplicado por 100 en coma fija decimal) y 100
@ en su respresentación en coma flotante
gx100:	.word	981
f100:	.float	100.0

@ Constantes. Textos para imprimir en la salida. resp es una cadena con formato.
preg:	.asciz	"> Introduzca la altura en metros:"
resp:	.asciz  "> La velocidad es de %f m/s."
prompt:	.asciz	"?:"

@ El siguiente valor simula la entrada del usuario, por eso se pone como
@ texto decimal. Se puede cambiar para ver cómo se calculan
@ correctamente otros resultados.
entero: .asciz	"25"

	.text

@ Aquí comienza el programa, primero lo que se llama programa principal.
main:
	ldr r2, =preg		@ Se va a imprimir el texto preg, a partir de la
	mov r0, #0		@  posición (0, 0) de la pantalla
	mov r1, #0
	bl  printString		@ Función de salida que imprime una cadena

	ldr r2, =prompt		@ Ahora en (0, 1) se imprime el prompt
	mov r0, #0		@  para que el usuario teclee la altura
	mov r1, #1		@  a continuación
	bl  printString		@ Función de salida que imprime una cadena

	ldr r0, =entero		@ Se simula la entrada mediante la cadena entero, el valor
	ldr r1, =h_leida	@  decimal obtenido (en coma fija por 100) se guarda en
				@  h_leida
	bl leedato		@ Función de que simula la entrada de datos

	ldr r0, =h_leida	@ Se lee de la posición de memoria h_leida el valor de la
	ldr r0, [r0]		@  altura y se guarda en el registro r0
	add r0, r0, r0		@ Se multiplica por 2 sumándolo consigo mismo
	ldr r1, =gx100		@ De la dirección gx100 se lee el valor de g
	ldr r1, [r1]		@  y se guarda en r1
	mul r0, r1		@ En r0 se guarda el resultado de 2*g*h
	bl  sqrt		@ Función que hace la raíz cuadrada de r0 y la deja en r0

	ldr r1, =vel		@ Se guarda la dirección vel en r1, y en esa dirección
	str r0, [r1]		@  de memoria se guarda el valor de la velocidad
				@  = sqrt(2*g*h)

	bl  escdato		@ Función de salida que imprime el resultado
	wfi

@ A partir de aquí comienzan las dos funciones auxiliares
@ leedato calcula un valor numérico a partir de la cadena de texto, y lo guarda
@ en memoria
leedato:
	push {r4-r5, lr}	@ Se guardan los registros adecuados
	mov r2, r0		@ En r2 se copia la dirección de la cadena con la altura
	mov r5, #10		@ En r5 se pone 10 para ir creando el valor decimal
	mov r3, #0		@ El resultado se inicia a 0
bucle:
	ldrb r4, [r0]		@ Se carga el valor de memoria
	sub r4, #'0		@ Se le resta el carácter 0 para obtener el valor de la
	                        @  cifra
	bcc finb		@ Si es negativo, es que se alcanza el final de la cadena
				@  y se acaba
	mul r3, r5		@  Se multiplica el resultado por 10
	add r0, r0, #1		@  Se suma 1 a r0 para leer el siguiente carácter
	add r3, r3, r4		@  Se suman las unidades actuales al resultado
	b  bucle		@ y se vuelve a leer
finb:
	mul r5, r5		@ Se pone 100 en r5 por la coma fija decimal
	mul r3, r5		@  se multiplica el resultado por 100
	str r3, [r1]		@  y se guarda en memoria

	mov r0, #3		@ Se imprime la cadena de entrada en (3, 1)
	mov r1, #1		@  tras el prompt, para simular la entrada
	bl  printString		@ Función de salida que imprime una cadena

	pop {r4-r5, pc}		@ Se recuperan los registros, incluido el pc para volver
				@  al programa principal

@ Escdato escribe en pantalla el resultado junto con unas cadenas para
@ que sea todo legible, usando printf y las funciones de coma flotante

escdato:
	push {lr}		@ Se guarda la dirección de vuelta
	bl qfp_int2float	@ Se convierte a coma flotante el valor de la velocidad 
	ldr r1, =f100		@ y se carga 100 en r1 para dividir en coma flotante.
	ldr r1, [r1]
        bl qfp_fdiv		@ el valor de la velocidad quedará en r0
	mov r3, r0		@ y se debe pasar en el parámetro r3 (corresponde a %f)
	mov r0, #0		@ Se imprime el texto con formato resp en la posición
	mov r1, #3		@  (0, 3) del display
	ldr r2, =resp
	bl  printf		@ Función de salida que imprime una cadena con formato.
	pop {pc}		@ Se recupera el pc para volver al programa principal
.end