calculadora programable - ies las musas...calculadora programable abstract circuito.....44...

Calculadora Programable

Creación y desarrollo de un prototipo libre.

Página dejada en blanco intencionadamente.

Calculadora Programable Abstracto

AbstractoDebido a las discrepancias y desigualdades existentes en el uso de las calculadoras en la enseñanza, es necesaria la creación de una calculadora pública que logre unificar el método de evaluación. El propósito de este proyecto es conocer qué está implicado en el funcionamiento de los dispositivos digitales que usamos en el día a día. Aplicando conocimientos diversos en matemáticas, electrónica y en informática se ha desarrollado un prototipo de calculadora funcional. El prototipo funcional permite ser adaptado para un posible futuro desarrollo. Este prototipo es capaz de resolver expresiones matemáticas y de representarlas en gráficas. Además, gracias al sistema creado, es relativamente sencillo añadir y extender nuevas funciones.

AbstractDue to discrepancies and inequalities in the use of calculators in education, it is necessary to create a public calculator that manages to unify the evaluation method. The purpose of this project is to know what is involved in the digital devices that we use on a day-to-day basis. Applying diverse knowledge in mathematics, electronics and computer science, a functional calculator prototype has been developed. The functional prototype can be adapted for a possible future development. This prototype is capable of solving mathematical expressions and of representing them in graphics. In addition, thanks to the system created, it is relatively easy to add and extend new functions.

Pág. 2

Calculadora Programable Abstract

Índice de Contenidos

Introducción..............................................................................................................................................6 Calculadoras de Configuración Básica...............................................................................................7 Calculadoras Científicas.....................................................................................................................7

Fundamentos............................................................................................................................................8 Nota aclaratoria..................................................................................................................................9

Objetivos del proyecto...........................................................................................................................10 Construir un prototipo de calculadora completamente funcional....................................................10

Principio Matemático.............................................................................................................................11 Sistema binario.................................................................................................................................11 Operaciones......................................................................................................................................12

Expresiones Matemáticas......................................................................................................................14 Reglas...............................................................................................................................................14 Principio de operación......................................................................................................................16 Implementación................................................................................................................................18 Mathinterpreter header.....................................................................................................................18 Mathinterpreter C source..................................................................................................................20

Matrices...................................................................................................................................................24 Matrices y coordenadas en el espacio..............................................................................................25

Humanizando las fórmulas....................................................................................................................27 Pantalla.............................................................................................................................................28

Gráficos...................................................................................................................................................30 Naturaleza de los píxeles..................................................................................................................30 Operadores en Imágenes...................................................................................................................32 Dibujando Líneas.............................................................................................................................33 Algoritmo de Bresenham.................................................................................................................34 Algoritmo de Bresenham (Con números enteros)............................................................................35 Dibujando Circunferencias...............................................................................................................36 A partir de la recta…........................................................................................................................38 Rellenar formas con un color determinado......................................................................................38

Imágenes..................................................................................................................................................39 Letras................................................................................................................................................40 Interfaz de Usuario...........................................................................................................................41

Diseño Electrónico..................................................................................................................................42 Procesador........................................................................................................................................42 Monitor LCD....................................................................................................................................43

Pág. 3

Calculadora Programable Abstract

Circuito.............................................................................................................................................44 Impresión del Circuito y Montaje....................................................................................................45

Conclusión...............................................................................................................................................46 Agradecimientos...............................................................................................................................47 Bibliografía del Proyecto.......................................................................................................................48

Apéndice A: Código y proyecto en git..................................................................................................49 Instrucciones para compilar..............................................................................................................49

Apéndice B: Imágenes del desarrollo...................................................................................................50

Pág. 4

Calculadora Programable Introducción

IntroducciónLas máquinas calculadoras han sido, desde el principio de la sociedad moderna, una invención puntera y excepcional. En ellas vemos reflejada perfectamente la huella que ha ido dejando tanto la tecnología como la ciencia en nuestra historia.

Probablemente, el primer paso que tomó la humanidad en dirección a la civilización vino de la mano de las matemáticas. Gracias a ellas conseguimos comprender mejor el mundo que nos rodea y podemos resolver muchos de los misterios que nos oculta el universo. Es por esto que, al mismo tiempo que al ser humano le dio por inventar las matemáticas, empezó la carrera por encontrar nuevos métodos más rápidos y eficientes en aquello de calcular. Así, fue inminente el surgimiento de la primera máquina calculadora.

Seguramente, el primer aparato matemático es el ábaco. A día de hoy, todavía es un misterio dónde y cuándo surgió este instrumento. Algunos sostienen que proviene de China y otros piensan que viene del desierto del Sahara. Lo que desde luego está claro es que desciende de una época muy temprana. Los primeros modelos, estaban compuestos por dos piezas fundamentales, unas piedras o tabas y un tablero o damero. El principio de operación era sencillo. Tan solo se colocaban y se movían las fichas por el tablero facilitando la resolución de operaciones simples; suma, resta, multiplicación y división. Pese a que pueda parecer un invento sencillo, lo cierto es que fue algo revolucionario. Para ponernos en perspectiva, primero tenemos que tener en cuenta que en esta época todavía no existían los algoritmos de cálculo que hoy en día vemos como habituales. Tampoco existía el sistema decimal ni mucho menos el álgebra. La gente operaba mentalmente de una manera y de otra sin ningún orden sobre cómo hacer las cosas. Por esto, hasta las operaciones mas triviales podían resultar un auténtico calvario. Gracias a la introducción del ábaco, se consiguió operar con números más grandes y complejos sin perderse. Tanto es así que el ábaco Griego, también conocido como calculus o piedras, definió el verbo que hoy en día utilizamos: calcular.

“Cálculo, hace referencia a la acción de realizar operaciones matemáticas, así como de la interpretación numérica de las mismas.”¹

Las personas tuvieron que esperar al menos un milenio más para poder disfrutar de un método más prestigioso. El siglo XVII fue un gran detonante en el mundo de las matemáticas. Y como la necesidad mueve montañas, las calculadoras experimentaron un gran avance. Así fue que en 1622 William Oughtred diseñó la primera regla calculadora. La regla calculadora supuso una gran mejora respecto a el modelo anterior debido a que era capaz de brindar los resultados mucho mas rápido y de una forma más cómoda. Ya no hacía falta mover un montón de piedrecitas de un lado a otro. Ahora, simplemente deslizando una barra de madera, podríamos resolver una operación. Aparte de la regla calculadora, que fue un gran éxito y se convirtió en algo habitual para cualquier matemático, en el siglo XVII se inventaron otros mecanismos más teóricos que aún tendrían que esperar un par de siglos para ver la luz a gran escala. Es el caso de Wilhelm Schickard quien desarrolló una máquina que casualmente lleva su nombre. La máquina de Willhelm era capaz de resolver con un

Pág. 5


mecanismo de reloj las cuatro operaciones básicas con números de hasta seis cifras. Desgraciadamente, esta máquina quedó en desuso y no se volvieron a plantear modelos parecidos hasta algo más tarde.En el siglo XIX, las calculadoras mecánicas empezaron a ser algo más frecuentes, algunas incluso introdujeron las bases de las computadoras y máquinas programables. A partir de aquí el mundo de la aritmética creció exponencialmente. A mediados de siglo, las máquinas ya eran capaces de resolver operaciones inmensas en cuestión de segundos. Un claro ejemplo es el de Ramón Verea, que en 1878 patentó un circuito de engranajes capaz de resolver operaciones tan complejas como 698.543.721 x 807.689 en tan solo 20 segundos. Poco después, grandes compañías empezaron a vender cientos de miles de calculadoras mecánicas siendo la Millionaire la más destacable del siglo.A principios del 1900, las calculadoras mecánicas siguieron avanzando pasando a ser cada vez más pequeñas y rápidas. Simultáneamente, el campo de la electrónica empezó a cambiar la forma en la que controlamos todos los aparatos, casualmente se creó la primera calculadora electrónica a finales de 1949. Como todos sabemos, la electrónica fue creciendo de forma exponencial. En poco tiempo pasamos de las válvulas de vacío a los transistores; se introdujeron los primeros circuitos impresos y empezamos a hablar de micrómetros en el tamaño de nuestros procesadores. Así, en los años 70, las calculadoras empezaron a ser algo asequible para todo el mundo. El desarrollo de estas calculadoras ha continuado hasta la actualidad mejorándose año tras año su potencia y funcionalidad. En los últimos años se han empezado a desarrollar sistemas de cálculo accesibles a través de internet, mucho más potentes y rápidos; e incluso existen plataformas que no solo resuelven las operaciones básicas si no que resuelven todo tipo de ecuaciones. Ahora que sabemos algo acerca de su historia, considero éste, el mejor momento para introducir su definición. Pese a que el catálogo de calculadoras posee un basto abanico de opciones, en la actualidad podemos distinguir entre dos grandes grupos.

Calculadoras de Configuración BásicaNormalmente están compuestas por una pequeña pantalla led de 8-10 caracteres, un teclado numérico con teclas especiales para sumar, restar, multiplicar, dividir y por un pequeño circuito embebido.

Calculadoras CientíficasEstas disponen de muchas más funcionalidades. Algunas permiten representar datos estadísticos, gráficas, resolver ecuaciones… Su capacidad es mucho mayor a la de las calculadoras básicas pudiendo representar números de hasta 9,99x10 ⁹⁹ . Su variedad operacional es también muy superior con funciones trigonométricas, raíces cuadradas, números aleatorios y fracciones.

En definitiva, las calculadoras científicas son virtualmente superiores a todos los modelos de máquinas calculadoras anteriores, siendo estas el claro modelo a elegir en caso de querer participar en cualquier actividad compleja. Dentro de esta clasificación, también existen dos tipos de calculadoras científicas, las embebidas, que disponen de un circuito diseñado únicamente para elaborar una tarea concreta, y las de propósito general, que integran un procesador capaz de ejecutar instrucciones. Esto permite que sean completamente programables y más versátiles que las embebidas.

Pág. 6


En este proyecto, centraré mis esfuerzos en especificar lo más detalladamente posible todos los sistemas involucrados en este último tipo de calculadoras. Como veremos a continuación, estos sistemas nada tienen que ver con el primitivo ábaco. Aún así, es importante recalcar que ambos comparten la esencia fundamental, ambos están hechos total y enteramente para satisfacer las demandas de nuestras preciadas matemáticas.

FundamentosYa se han dejado claras todas las características que rodean al término calculadora científica. Pese a todo, lo cierto es que es muy diferente saber reconocer el objeto a saber crearlo. Tenemos que tener en cuenta que todo, desde el acabado de la tapa hasta el programa que resuelve ecuaciones, no se generaron espontáneamente, ni mucho menos, si no que han sido el fruto del trabajo y esfuerzo de muchos. Por eso, ahora, hago una llamada al espíritu de ingeniero del lector, para que se pregunte ¿cómo se hace una calculadora?

Bajo la experiencia recogida durante la realización de este trabajo, se han definido tres pilares esenciales a tener en cuenta. Dichos pilares son, la electrónica involucrada, la informática presente, y las matemáticas.

La matemática es el cimiento que sostiene a nuestra máquina. Sin ella no seríamos capaces de empezar. El primer paso para resolver el problema es conocerlo bien. En las matemáticas encontraremos respuesta a muchos de los problemas aquí propuestos. Es muy importante saber cómo dividir o multiplicar así como conocer los entresijos de la lógica proposicional. En este proyecto no usaremos la matemática de una manera resolutiva si no más bien discreta. No se trata de resolver ecuaciones. Usaremos la matemática para optimizar y hacer realidad operaciones partiendo de ceros y unos.

Más allá de eso, está la informática, que nos sirve de puente entre la idea abstracta, matemática, con la realización física de la misma. A través de ella, definiremos cada uno de los pasos que hay que seguir para llegar al resultado buscado. Todos los pasos estarán definidos en forma de algoritmo, una receta que ha de ser ingeniosa para ser capaz de tratar la información adecuadamente.

Por último, está la electrónica, que como obreros construyendo un edificio, será la que lleve a cabo todo en nuestro mundo físico. Ésta será la encargada de transformar un algoritmo en algo “tangible” utilizando diversas técnicas. En el proyecto, no voy a profundizar demasiado en este tema, pues la complejidad de un sistema como un procesador es excesivamente extensa. Sin embargo, intentaré dejar claros algunos de los problemas que se me han presentado.

Para crear este trabajo utilizaremos algunas herramientas modernas presentes a nivel doméstico. Desde el principio del proyecto, se ha intentado probar lo que se puede hacer hoy en día de forma casera y autónoma. Por eso, hemos seguido ciertas reglas con la intención de que el proyecto sea lo más completo posible. Para la ejecución del proyecto solo se han utilizado programas de código libre o de licencia gratuita. Además, todas las herramientas empleadas son de uso no industrial, lo cual ensalza la actitud de prototipo de sencilla producción.

Pág. 7

Calculadora Programable Fundamentos

Hoy en día existen procesadores capaces de ejecutar cálculos y funciones con una precisión extraordinaria. Sin embargo, dado que la intención del proyecto no es la de crear una calculadora futurista con sus mucho gasto de potencia y sus luces de neón; se utilizarán procesadores más limitados y básicos que encajen mejor las necesidades de una calculadora científica. De esta forma, el prototipo no estará malgastando recursos y será viable económicamente hablando.Además, el hecho de que partamos de un procesador más básico permite que el proyecto sea aún más didáctico, pues habrá que intentar hacer las cosas de la mejor manera posible o de lo contrario el procesador se saturará.Otro aspecto donde se ha tenido en cuenta ser lo más libre y completo posible es en la elección de sistema y lenguaje de programación. Para cumplir esta tarea, hemos decidido que la mejor opción es utilizar el lenguaje de programación C como base para el proyecto. El lenguaje de programación C ofrece ciertas características que permiten un uso más optimizado del procesador. Gracias a que C no es un lenguaje de alto nivel, éste se ejecuta más rápido y utiliza menos memoria. Por supuesto, utilizar un lenguaje como C viene acompañado de ciertos inconvenientes. Además, de todo el control y velocidad que ofrece, añade varios niveles a la responsabilidad necesaria en el código. Usar C, sin lugar a dudas, significa más tiempo y trabajo que utilizar un sistema de alto nivel como python o JavaScript. Usando C tendremos que tratar con elementos más sencillos con herramientas más limitadas.

Nota aclaratoriaDurante todo el proyecto utilizaremos la notación inglesa para expresar números, así como ciertas palabras provenientes del idioma anglosajón. Por lo tanto el número 1.234 ha de leerse como “Uno coma doscientos treinta y cuatro” y no como un decimal. Esto simplifica las explicaciones pues, el compilador de código C usa la notación inglesa.

En todas las expresiones lógicas intentaremos hacer uso del sistema proposicional utilizando los caracteres originales. No obstante, es posible que en alguna ocasión utilicemos directamente aquellos usados en C. Para aclararlo:

Y, and O; or No; not

^ ∨ ¬

& | ~

Pág. 8

Calculadora Programable Objetivos del proyecto

Objetivos del proyecto

Construir un prototipo de calculadora completamente funcional.Para cumplir con el término “completamente funcional”, tiene que ser capaz de completar parcial o totalmente tres objetivos principales:

1. Tener todos los componentes necesarios para su total funcionamiento. Entre sus componentes se incluyen:

● Procesador principal al que estará destinada la carga aritmética.

● Periféricos de entrada/salida que permitirán la comunicación entre usuario y máquina. El dispositivo dispondrá de:

○ Una pantalla capaz de representar tanto los datos introducidos por el usuario como aquellos obtenidos por el procesador.

○ Un teclado en el que el usuario podrá introducir los datos requeridos e interactuar con la máquina.

○ Todos los componentes han de estar unidos en un circuito electrónico.○ La calculadora tiene que ser relativamente fácil de programar.

2. Ser capaz de resolver una aritmética básica. Su programación tiene que ser capaz de calcular:

● Las cuatro operaciones naturales; suma, resta, multiplicación y división.

● Razones trigonométricas. seno, coseno, tangente.

● Funciones y representarlas en una gráfica.

● Ecuaciones de segundo, tercer y cuarto grado.

3. Ser ergonómico y fácil de utilizar por el usuario. Para ello se trabajará el aspecto exterior de la calculadora intentando diseñar una carcasa. Además se pulirá el software y cada uno de sus componentes con el fin de obtener una buena experiencia.

Además, en los objetivos se busca resumir toda la tecnología que hay detrás del dispositivo. Se publicarán de manera libre todos los diseños aquí creados.

Pág. 9

Calculadora Programable Principio Matemático

Principio Matemático

Sistema binarioEn nuestra ardua tarea por la búsqueda de un artilugio calculador, tenemos que empezar, como no iba a ser de otra forma, por los números. La primera pregunta que nos surge es cómo podemos definir un número.Quizá, el método más elemental para representar un número se describe en forma de cuenta. Este es el método más sencillo y no es de extrañar que fuera el primero.Para representar números en forma de cuenta, tan solo tenemos que dibujar tantos elementos como unidades tenga el número. Por ejemplo, el 1 se representaría como ●; el dos como ●●; el 5 como ●●●●●… Es muy fácil encontrar problemas a este método. Es muy lento y lioso, prácticamente es imposible representar números de más de dos cifras. Por ello, rápidamente se crearon nuevos métodos que empezaron a organizar los números en símbolos. Por ejemplo, en el sistema romano el 1 es I, el 5 es V, el 10 es X… Para representar cifras tan solo juntamos estos símbolos de manera que se sumen, V+I, VI es 6, X+I, XI es 11… Por supuesto, hay otras reglas que no creo sea necesario nombrar.* Pese a que con este sistema simbólico arreglamos muchos de los fallos de contar, sigue siendo un sistema algo difícil. La verdadera revolución del número se introdujo con la creación del sistema de números base.Para que nuestro sistema sea de números base todos los símbolos han de ser consecutivos y empezar en 0. Queda descartado entonces el romano pues del 1 pasamos al 5 y del 5 al 10 etc. En el sistema decimal existen símbolos para cada número del 0 al 9, todos consecutivos. La base del sistema equivale al número de símbolos que existan. En el caso del decimal existen 10 números por lo que la base es 10. Si usásemos 8 símbolos, el sistema sería base 8 o octal. El modus operandi de este sistema usa las potencias de los números base. Para un número N, representamos el número en base X de la siguiente forma:Primero calculamos los coeficientes de cada exponente dividiendo entre la base progresivamente. Así en esencia conocemos cual es la suma de los exponentes de la base que forma ese número.

Por ejemplo, para pasar el número 93 a base octal haríamos lo siguiente:

93 |8 5 11 |8 → 135 o también 1×8²+3×8¹+5×8⁰ 3 1 Cada vez que dividimos entre la base hallamos cuánto falta para llegar al exponente siguiente. En el primer paso 93 esta formado por 8 × 11 + 5, en el siguiente paso vemos que el 11 a su vez esta formado por 8 × 1 + 3. Desarrollando esto tenemos que el número esta formado por: 5 + 8 × (8 × 1 + 3) = 5 + 8 × 3 + 8 × 8 × 1 y así llegamos a la estructura de números de base.

*El sistema de numeración romana es más compleja de lo que se describe aquí.

Pág. 10


Podemos definir una regla general para un número natural N de base B: NB=±∑

i ∈ℤa i×Bi

● a es el dígito en la base B correspondiente.

OperacionesAhora que hemos clarificado el método que vamos a utilizar para representar números, tenemos que pensar cómo podemos hacerlo en nuestra máquina. Aquí entra en juego la lógica binaria, la más sencilla y viable de todas las lógicas. Cuando hablamos de lógica binaria nos referimos a aquella en la que los valores correspondientes tan solo se dividen en dos: verdadero o falso.En resumen, nuestra máquina usará un sistema de lógica binaria. Como no iba a ser de otra forma, nuestros números estarán en base 2, es decir, se representarán con 0 y 1.Podemos hacer cosas muy interesantes con el sistema binario. Podemos sumar, restar, multiplicar y dividir.

Propuesta la suma 5, en binario 101, más 9, en binario 1001, usando el algoritmo convencional:

101 ⟶ 5 + 1001 ⟶ + 9

1110 14

La resta 9 - 5:

1001 ⟶ 9 - 101 ⟶ - 5

100 4

Multiplicación 9 × 5

1001 ⟶ 9 × 101 ⟶ × 5

1001 45 0

1001 101101

Por último división 9 ÷ 5

1001 | 101 9 |⟶ 5 101 1 4 1 100

Pág. 11


Para trasladar este algoritmo a una máquina, lo más sensato es el uso de la conjunción, negación y disyunción, que serán realizadas en nuestra calculadora a través de puertas lógicas.Como sabemos a través de nuestro algoritmo convencional, cuando la suma de las unidades rebosa al número base, es necesario guardar lo que rebosa en algún sitio para sumarlo más tarde, aquello que llamamos “lo que me llevo”. Estas son las reglas que seguimos al sumar:

Valor A

Valor B Resultado

0 0 0

0 1 1

1 0 1

1 1 0 + carry

Podemos expresar la tabla de la suma de la siguiente forma:

R=(( A∨B∨C )∧¬(( A∧B)∨( A∧C)∨(B∧C )))∨( A∧B∧C )

D=(A∧B)∨(A∧C )∨(B∧C)

Donde...

• A es el primer valor

• B es el segundo valor

• C corresponde al carry de la cifra anterior.

• R corresponde al resultado.

• D indica el carry de la siguiente cifra.

Usando esta expresión en cada una de las cifras de los números a sumar, hemos creado un método para sumar a partir de la lógica. Para la multiplicación, no tendríamos que hacer nada más que sumar un número concreto de veces, por ejemplo si tenemos la multiplicación 5 × 4, tan solo tenemos que sumar 5 cuatro veces = 5+5+5+5.

Para restar nos basaremos en las reglas de la suma, sin embargo tenemos que cambiar la expresión del carry. Para la resta, corresponderían estas fórmulas:

R=R suma

D=(B∧¬A)∨(C∧¬A)∨(B∧C )

Pág. 12

En esta tabla definimos el comportamiento de una suma. En caso de que la suma sea 0+0 el resultado es 0, si es 0+1 el resultado es 1. En caso de que ambos sean 1 entonces tenemos que guardar lo sobrante en algún sitio. En este caso lo llamaremos carry.En caso de que el carry del número anterior sea 1,entonces solo tenemos que negar los valores de esta lista.


Igual que con la multiplicación, para dividir tan solo tenemos que restar hasta que el número resultante sea menor al divisor.Hay que decir que tanto la multiplicación como la división pueden optimizarse. Pero para simplificar las cosas usaremos la suma y la resta para multiplicar y dividir.En resumen, gracias a que usamos un sistema binario, podemos representar en forma de lógica expresiones como la suma, la resta o la multiplicación. Más tarde, ya en nuestra máquina calculadora, nos valdremos de puertas lógicas para llevar a cabo las diversas operaciones sencillas.

Expresiones MatemáticasAunque ya conocemos los entresijos de sumar, restar, multiplicar y dividir, todavía nos encontramos bastante lejos de lo que sería adecuado llamar calculadora científica. Éstas son capaces de analizar varias operaciones a la vez en una frase llamada expresión matemática. Cuando organizamos varias operaciones en una misma línea, conseguimos que un cálculo sea mucho más visual e intuitivo. Además, esto permite una fácil reutilización de datos durante su uso. Por consiguiente, tendremos que desarrollar un programa capaz de leer expresiones matemáticas y transformarlas en un resultado numérico.

ReglasLo básico para buscar una solución a este problema es saber de antemano cómo representamos las expresiones matemáticas. Existen unas reglas concretas que estandarizan la forma en la que leemos las expresiones. Así, aseguramos que una expresión tiene siempre el mismo resultado.

Una expresión matemática es por ejemplo: 5+3×(−2+4)

En esta expresión encontramos diferentes símbolos que no hemos tratado aún. Ya conocemos los números y las operaciones pero hasta ahora no hemos tenido en cuenta nada más. Fijémonos en cada una de las partes que componen la expresión de ejemplo.

5⏟N 1

+⏟O 1

3⏟N 2

×⏟O 2

( -⏞O3

2⏞N 3

+⏞O4

4⏞N 4

)⏟P 1

Tenemos un total de cuatro números y cuatro operaciones. Sin embargo, todavía no hemos decidido como interactúan cada una con la otra. Por ejemplo, si proponemos la expresión 2 × 3 + 4. Sabemos que “×” corresponde a una multiplicación y “+” a una suma. Entonces podemos empezar a intentar resolverla. 2 × 3 = 6 → 6 + 4 = 10, este sería un resultado, pero obtenemos otro si hacemos 3+4 = 7 → 2 × 7 = 14. Para arreglar esto, en matemáticas existe algo llamado la jerarquía de operaciones, que marca el orden por el cual se tienen que resolver cada una de ellas. El orden es el siguiente: +, -, ×, ÷; siendo la división lo primero y la suma lo último.

Pág. 13

Calculadora Programable Expresiones Matemáticas

Aún nos queda hablar del último tipo de operador que encontraremos, el paréntesis. Según nuestro nivel de jerarquía, el paréntesis es lo que se ha de calcular primero. A su vez, el orden de los paréntesis, viene definido por el nivel en el que se encuentran.

Como podemos ver, en esta expresión coexisten tres niveles de paréntesis. En el primer nivel se encuentra todo aquello que no esté entre paréntesis, es decir: 5, × y el primer paréntesis. En el siguiente nivel se encuentran: 2, +, y el segundo paréntesis. Por último, en el tercer nivel están los números 3 y 4 formando una multiplicación.

Según las reglas jerárquicas, para leer correctamente esta expresión hacemos primero lo que esté en los niveles más altos. En este caso 3 × 4 = 12; después calculamos lo del segundo nivel, 2 + 12 = 14; y por último, aquello que no esté entre paréntesis 5 × 14 = 70.

Para terminar con la lectura de fórmulas, hay que añadir que éstas se leen de izquierda a derecha.

Lo siguiente en las reglas de las expresiones es la estructura de operaciones. Por lo general, todas las operaciones presentan la siguiente estructura:

En esta estructura, cada operador viene acompañado siempre de un miembro a la derecha y de otro miembro a la izquierda. A su vez, estos miembros no pueden ser operadores. Por ejemplo 5 ×+ 3 no tiene ningún sentido. Los miembros solo pueden estar formados por tres elementos. Por números, por paréntesis o por funciones. Estas últimas las dejaremos de lado por ahora para evitar complicar la teoría.

Ahora bien, pese a que la mayor parte de las veces las operaciones adoptan esta estructura sencilla y controlada, hay algunos casos en los que están permitidas ciertas excepciones.A la estructura en la que todos los operadores tienen dos miembros se le llama estructura fija.

La primera excepción es la del uso del menos para indicar un número negativo.En caso de que tengamos una expresión como -2 × 5 o 4 + (-3), el menos esta acompañado tan solo por el miembro a la derecha. Este menos, se utiliza para indicar el signo del número y no define una operación como tal. Aún así, podemos evitar esta excepción sustituyéndola siempre que la veamos por una expresión equivalente. ej. -1×2 × 5 o 4 + (0 – 3)Existe la excepción +-1 en el que un menos esta junto a un más. En esta ocasión, ambos definen el signo y sería incluso correcto utilizarlo como 4 × (+-1). De todos modos, la utilidad de esto cae un poco en controversia. Pues a diferencia del menos para mostrar el símbolo, que simplifica la operación, utilizando esta excepción no obtenemos ningún beneficio ya que siempre es mas sencillo colocar el signo resultante. Por esta razón, esta excepción no la tendremos en cuenta.

Pág. 14

5×(2+(3×4)⏞Nivel 3

)⏟Nivel 2⏟

Nivel 1

232 ⏟Miembro A

+ ⏟Operador

64 ⏟Miembro B


La segunda excepción ocurre con los monomios. Para definir una multiplicación necesitamos, siguiendo con la estructura estándar, dos miembros, uno a cada lado del operador. Sin embargo, esto en muchas ocasiones es un estorbo, haciendo que las operaciones sean mucho más largas innecesariamente. Por consiguiente, aprovechándose de las propiedades naturales de la multiplicación, tiene sentido que cuando se pueda se intente omitir el operador. ej. 2(3 + 1) que significaría lo mismo que 2 × (3 + 1) pero se ha omitido el operador con el fin de simplificar.A diferencia de la excepción anterior, en este caso, ambos miembros están presentes en la operación y lo que falta es la operación en sí. Encontraremos esta excepción en caso de que un número se multiplique con un paréntesis, que un número se multiplique con una función, o que una función o paréntesis se multiplique con otra función o paréntesis.Entonces, ahora que tenemos claro las reglas básicas involucradas en las expresiones matemáticas, podemos empezar a plantearnos un método para resolverlas.

Principio de operaciónPara empezar a explicarlo, empezaré hablando de la estructura de datos en una fórmula. ¿Por qué elementos esta formada una expresión matemática? Parece una pregunta sencilla, pero la verdad es que la lista es bastante larga. Por un lado tenemos los números que pueden ser tanto enteros, como decimales. Luego tenemos todos los operadores a tratar, desde la suma hasta raíces y potencias. No nos podemos olvidar de ciertas funciones esenciales, como las trigonométricas. Y, por si fuera poco, también tenemos que tratar con los paréntesis. Todas estas son estructuras presentes en una expresión matemática cualquiera. Y por ello, nuestro programa ha de ser capaz de saber interpretar todas y cada una de ellas. Aún así, aunque tuviésemos un método para interpretarlas, aún tendríamos que enseñar al usuario a introducirlas. En general, los seres humanos escribimos letra a letra, número a número. Es así como pensamos cuando organizamos las expresiones. Está claro que agradecemos las herramientas de auto-completado o algunas predicciones. Sin embargo, nos gusta ser libres en nuestra forma de escribir. En el caso de limitar la acción del usuario a tan sólo poder escribir las operaciones de una única forma, marcada por la calculadora, pondríamos en seria duda la libertad del usuario. Por eso, y con intención de ser lo más intuitivo posible, nuestro lector no tratará directamente con estas estructuras. Sino que tendrá que aprender a interpretar, uno a uno, cada uno de los caracteres escritos en la pantalla. De esta forma, una vez interpretados estos como estructuras, podemos intentar empezar a resolverlos.En definitiva, aquello que el programa va a leer al principio no va a ser nada más que una cadena de caracteres. Las cadenas de caracteres están formadas por números posicionados uno detrás del otro. Por ejemplo: “H”, “O”, “L”, “A”. Podemos asignar a cada uno de los caracteres un número, siendo la H el 0, la O el 1… De esta forma, podemos contar nuestra lista y podemos movernos a través de ella. Teniendo en cuenta esto, concluimos que para acceder a un caracter, solo necesitamos saber la longitud de la lista y su posición.

Pág. 15


Con estas bases, podemos hacernos una idea de como va a leer nuestro programa. Esquemáticamente:

Obtener la expresión

Leer ún caracter

¿Es un operador?

Crear operación

Obtener la expresiónde los dos miembros

Sí

Ir al siguiente caracter

¿Final de la expresión?

No

No

Leer “monomio”

Sí

El primer paso consiste en obtener del usuario la expresión matemática que va a utilizar. Una vez se tiene, se continúa leyendo el primer caracter. Como se explica en el diagrama, se comprueba si es un operador o si no. En caso de serlo se pasa a intentar identificar la operación. En este paso, primero se define nuestro operador en la memoria y después, se vinculan todos los miembros del operador a las otras dos partes de la expresión. Una vez creado nuestro operador, seguimos leyendo los miembros de éste. Durante la ejecución del programa, seguiremos creando operación tras operación hasta llegar a un “monomio”. Término entendido como una unión de números, funciones y paréntesis en los que no esta presente el operador de la multiplicación.

Este método tiene un problema notable. Cuando leemos una expresión usando una estructura recursiva, estamos forzando al programa a leer la misma expresión una y otra vez. Por este motivo, el programa va a tardar más en llegar al resultado. Lo ideal es registrar cada número tan solo una vez. Uno de los métodos más eficientes para resolver este problema se basa esencialmente en modificar la expresión introducida con el fin de ser más fácil de entender por el sistema. De esta manera, en el momento de leerse un operador, es más fácil relacionarlo con cada uno de sus miembros. Una de las formas más conocidas para organizar una expresión matemática es la conocida como Polish postfix notation. A diferencia del diagrama, en vez de leer directamente la expresión, primero la convertimos en algo más fácil de interpretar por un procesador. Por ejemplo, en notación PPN (4 - 2) × 5 quedaría

Pág. 16


transformado en 4 2 – 5 × y 4 – 2 × 5 sería 4 2 5 × –. Los números utilizados en el segundo caso son 4, 2, 5 en orden. La primera operación es la multiplicación seguida de una suma. En PPN colocamos primero en orden todos los números de la operación y después el operador. Algo completamente diferente a la estructura número, operador, número. Todas las expresiones escritas así son mucho más sencillas de procesar, tan solo hay que encontrar el primer operador empezando desde la derecha y una vez encontrado, usarlo para operar con los dos números a la izquierda. En resumen, usando PPN, primero se escriben los miembros a utilizar seguidos de las operaciones. De esta manera es más sencillo leer los datos. Además, si nos fijamos en este caso, PPN no es nada ambigua y no hace falta tratar con la jerarquía de operaciones. Entonces, ¿Por qué no usamos éste método? La razón principal es la falta de recursos previos en el desarrollo. Este método requiere el uso de listas dinámicas en las que se vaya guardando la información. Listas que, por la naturaleza de C, habría que definir. Además, este proceso consta de dos grandes partes, primero traducir una expresión algebraica a PPN y después resolver el PPN. Mientras que en el método definido por el diagrama, aunque conste de las mismas partes, difiere en el proceso de resolución que al ser tan simple es casi insignificante. Definitivamente, con más recursos y tiempo, el segundo método sería preferible. Pero por su sencillez, el primero es el que incluirá nuestra calculadora.

ImplementaciónComenzaremos hablando sobre la estructura del proyecto. Con el fin de hacer el proyecto lo más fácil de modificar y portar a cualquier plataforma, intentaremos separar todo aquello específico de cada dispositivo de todo aquello que es base general. Por este motivo todos los archivos del intérprete matemático estarán incorporados en la parte considerada multiplataforma. La parte de intérprete matemático ha de ser lo más sencilla posible con el fin de poder usarlo con facilidad en cualquier momento. Los primeros archivos que se incluyen al proyecto son mathinterpreter.c y mathinterpreter.h .

Mathinterpreter headerEn el archivo H quedan definidas todas las funciones así como todas las estructuras a utilizar. Las primeras definiciones consisten en todos los tokens o caracteres clave que vamos a usar.

// Character code

#define MI_NUM 'N' // Caracter para referirnos a un número

#define MI_FUN 'F' // Caracter para funciones

#define MI_PLUS '+' // Indica suma

#define MI_MINUS '-' // Indica resta

#define MI_MUL '*' // Indica multiplicación

#define MI_DIV '/' // Indica división

#define MI_POW '^' // Indica un número elevado a otro

#define MI_SUB_OPENER '(' // Caracter que abre paréntesis

#define MI_SUB_CLOSER ')' // Caracter que cierra paréntesis

#define MI_COMMA ',' // Coma para distinguir entre argumentos de cada función

Pág. 17


En el archivo H también definiremos todas las estructuras que vamos a necesitar. Estas estructuras guardarán la información de manera distinta dependiendo de si son operadores, números o funciones. Aún así, todas ellas tienen que ser capaces de unirse e interactuar entre sí para ser capaces de formar un árbol de información. Dicho árbol juntará todos los elementos de la operación de una manera lógica tal como se muestra a continuación:

Para lograrlo utilizaremos una union . Gracias a esta unión, podemos juntar los objetos entre sí y conocer su tipo de una forma más sencilla. Para poder usar las uniones, el primer byte de la unión siempre guardará el tipo de objeto al que nos estamos refiriendo. En total, usaremos cuatro estructuras distintas para guardar cada tipo de objeto. Cada una de ellas está definida de la siguiente forma:

• Estructura para números.

typedef struct{

char type;

float value;

} Mi_Num_Node;

Los números tan solo necesitan su valor y el byte que guarda su tipo.

• Operadores.

typedef struct{

char type;

void * a;

void * b;

} Mi_Op_Node;

Los operadores necesitan guardar su tipo y la posición en memoria de los dos miembros, a y b.

Pág. 18


• Funciones

typedef struct{

char type;

int fun_type;

Mi_Args * args;

} Mi_Fun_Node;

Estas guardarán tres valores, su tipo; el código de la función y por último todos los argumentos de la función.

• Error

typedef struct{

char type;

char code;

char * error;

} Mi_Err_Node;

Parecidas a las funciones, guardan tipo, código de error y mensaje.

Mathinterpreter C sourceEn cuanto a el archivo C, En el estará definido todo el código que vamos a utilizar. La primera función es mathinterpreter_eval(char * equation, int len, Mi_Err_Node * error) .

Esta función toma tres argumentos. La variable nombrada como equation guarda la dirección de la cadena de caracteres. La variable len guarda el tamaño de la expresión matemática con el fin de recorrerla más fácilmente. El último argumento, error , guarda un puntero a el mensaje de error. Este argumento será nulo a no ser que haya un error en la resolución de la expresión o ésta esté mal escrita.

Desde mathinterpreter_eval llamaremos a las otras dos funciones principales: mathinterpreter_read y mathinterpreter_solve .

En mathinterpreter_read se llevará acabo toda la acción del algoritmo, aquí pasaremos de una cadena de caracteres al árbol que representa la expresión matemática. mathinterpreter_read se encargará primero de dividir y estructurar la expresión en operaciones y después de crear los monomios.

Para ello, mathinterpreter_read detecta todos los operadores en orden y respetando los paréntesis.

Por ejemplo, si queremos leer 5 × ( 2 + 1 ) esta sería la representación que mathinterpreter_read haría:

Paso 1: 5 × ( 2 + 1 ) Operación detectada.Paso 2: leer 5

Paso 3: 5 Monomio detectado.

Paso 4: leer ( 2 + 1 )

Paso 5: 2 + 1Paso 6: leer 2


Paso 8: leer 1


Pág. 19


Los operadores se leen de derecha a izquierda, de esta forma todos aquellos que están más a la derecha se resuelven más tarde, es decir quedan más alto en el árbol binario; y todos los que están a la izquierda se resuelven antes, quedan más bajos en el árbol binario. En este punto, en cuanto el programa encuentra una operación, se puede cargar en memoria directamente.Sin embargo, a diferencia de la operación, con sólo detectar un monomio no podemos saber su composición. Esto es porque los monomios no son simples símbolos, si no que también son una unión de distintas cosas. Por ejemplo, 2 es un monomio, entendido con la definición explicada anteriormente, y 3.24sen(90) también lo es.

Para leer un monomio, tenemos que tener en cuenta el grupo al que pertenece cada caracter. Sabemos que todos los números del 0 al 9 y la coma pertenecen al grupo número. Para simplificar, todas las letras pertenecerán al grupo función, y todo aquello entre paréntesis pertenecerá, por consiguiente, a un paréntesis. En resumen, para definir nuestro monomio, dividiremos en dos grupos cuando se detecte un cambio de grupo. Si tenemos 4sen(90), tenemos que dividir la operación en el cambio de grupo, 4---sen(90). Si en su lugar tuviésemos algo como EPI, no podríamos leer nada, pues no hay forma de diferenciar las dos funciones (e y pi). La función que se encarga de leer los monomios se llama mathinterpreter_read_mono .

Aunque ya hemos definido cómo interpretar los monomios, todavía quedan elementos por desarrollar, porque aún seguimos sin poder leer ni números, ni funciones, ni paréntesis. Para los paréntesis, la solución es sencilla, simplemente hay que procesar lo que hay dentro como una expresión cualquiera. Sin embargo, tanto para los números como para las funciones, tenemos varios problemas.Utilizando lo que ya sabemos del sistema de bases, no es muy complicado hacerse una idea de como pasar de caracteres a un número en sistema decimal. Para ello, lo único que tenemos que hacer es multiplicar cada número por la potencia de 10 correspondiente. Por ejemplo si tenemos el 342 podemos crear una expresión numérica de la siguiente forma: 3 × 10² + 4 × 10 + 2. Si el número contiene decimales, tan solo tenemos que seguir contando coeficientes a partir del 0, es decir, multiplicamos por 10 ¹, 10 ², 10 ³…⁻ ⁻ ⁻Para leer funciones se asigna un nombre a un algoritmo. Por ejemplo, el algoritmo que calcula el seno de un ángulo α va a estar vinculado al nombre “sin”. Entonces, para saber qué función es, comparamos el nombre de la función escrita en la expresión con el registro de funciones. En caso de que coincida con alguna, podemos decir que se trata de la misma función.Si todo ha ido bien hasta este punto, en nuestra memoria se tiene que alojar el árbol correspondiente a nuestra expresión. Ya solo queda resolverlo.

Para resolver el árbol, tenemos que empezar por todo aquello que esté más alejado del principio. Por eso empezaremos resolviendo todas las operaciones que sólo estén unidas a números o funciones. Una vez resueltas estas operaciones, sustituimos la operación por el resultado y volvemos a resolver aquellas que sólo estén unidas a operaciones. Repetimos el proceso hasta llegar a la última operación. Figura.1

Pág. 20


Como vemos en las Figuras 1, 2 y 3 resolver operaciones es algo sencillo.En definitiva, después de leer, estructurar y resolver una expresión, nuestro programa debería de ser capaz de darnos un resultado con total fidelidad. Sin embargo, la realidad es algo distinta. A parte de la lentitud para resolver una expresión, que ya se ha comentado en el documento anteriormente, existe una limitación relacionada con la exactitud del resultado. Para representar los números y que la carga no sea excesiva, es decir, que el programa no tarde demasiado a la hora de hacer operaciones, no operamos con un número normal y exacto, si no que en su lugar usamos un número de punto flotante.En vez de guardar absolutamente todas las cifras del número, los números flotante o floating point numbers en inglés tan solo guardan una cantidad de cifras significativas junto con un exponente y una base tal y como se muestra en el diagrama:

3.14159=314159⏟cifras

× 10⏟base

−5⏟exponente

De esta forma, podemos representar un rango mucho mayor de valores sin arriesgar mucha memoria, ni mucho tiempo de procesamiento. Obviamente, al reducir la cantidad de cifras significativas a un número determinado, todo aquello que sobrepase este rango, quedará completamente descartado de la operación. Por tanto, sumar un número muy pequeño a otro muy grande es insignificante. Además de este tipo de truncamiento, durante las operaciones con números flotantes se llevan a cabo una serie de aproximaciones que optimizan el proceso. Por estas razones, después de unas cuantas operaciones, es posible que el resultado real y el presentado por la calculadora sean distintos.No hay una forma sencilla de evitar esto a gran escala. Aún así, podemos tener en cuenta ciertas excepciones donde sea más significativo.Podemos limitar ciertos casos conocidos. Por ejemplo, el seno de 0º, 90º, 180º y 270º son casos conocidos. Es muy probable que si el ángulo que procesa el programa es muy parecido a estos valores, esto se deba al error que cometen las operaciones, y no a que el usuario quiera calcular el seno de, por ejemplo 90.0001º. En estos casos, el valor será invariable en un pequeño rango, de esta forma evitamos los errores más significativos. Sin embargo, esta medida no soluciona el problema del todo, y en operaciones muy largas vamos a seguir arrastrando un error. La solución a esto, radica en tener en

Pág. 21

+2

×

3 4

Figura 1: Dado que 3 y 4 son números, se calcula primero la suma

72

×

3 + 4 = 7

Figura 2: Sustituimos por el resultado de la operación

72

×

2 × 7 = 14

Figura 3: Terminamos calculando la multiplicación


cuenta el error acumulado a la hora de calcular operaciones. El método más famoso se llama Algoritmo de suma de Kahan. Dicho algoritmo guarda el error acumulado en una variable que después se resta al resultado.Dado que un número flotante tan solo puede guardar una cantidad concreta de cifras significativas, al guardar dos cifras, el resultado y el error, estamos aumentando el número de cifras significativas.Pese a las ventajas de usar un error acumulado, he valorado que el programa de la calculadora prescindirá de su utilización. Se trata de una complicación más que obligaría al programa a rehacer todos los algoritmos de cálculo. Aún así, es algo que puede implementarse en el futuro. En resumen, el error de los números flotantes es un problema que no vamos a terminar de solucionar en este proyecto. De todos modos, el programa intentará redondear las cifras significativas con el fin de minimizar el error.Obviamente, lo descrito en este documento simplifica muchos de los procesos que están presentes en este prototipo. Considero que contar absolutamente todos y cada uno de ellos es un despropósito. Hemos preferido explicar adecuadamente las bases del algoritmo siendo amenos, claros y concisos, a rebosar la paciencia del lector con una saturación de información. En caso de querer conocer de manera más exhaustiva el código, basta con referirse a la carpeta /extensions/mathinterpreter dentro del proyecto. Esta carpeta encierra todo el contenido del intérprete.A efectos prácticos, es reconfortante ver por primera vez el prototipo de calculadora. Como no podía ser de otra forma, en la siguiente imagen presentamos la primera versión funcional resolviendo 2+2:

Pág. 22


Con esta implementación, ya tenemos un programa capaz de resolver operaciones a gusto del usuario.Sin embargo, el uso que le podemos dar en este estado es bastante reducido. Todavía el programa está supeditado a un ordenador del siglo XXI y como hemos hablado anteriormente, esto no tiene mucha utilidad. El programa es poco intuitivo y complicado. Sólo podemos introducir la expresión en una “consola de comandos” y esperar a que nos devuelva un resultado en forma de texto. Recuerda un poco a un recibo o a un ticket más que a una calculadora.

MatricesUna de las cualidades más interesantes que podemos encontrar en las calculadoras actuales es la capacidad de resolver sistemas de ecuaciones. Este tipo de herramientas se vuelven muy útiles a la hora de simplificar y automatizar el trabajo. Para resolver sistemas lineales utilizaremos matrices. Aunque no se trate del método más eficiente, las matrices han demostrado ser muy intuitivas y fáciles de utilizar. Una vez definimos funciones básicas como sumar, restar, multiplicar y calcular la inversa, podemos utilizarlas de una forma sencilla para obtener el resultado de largos sistemas de ecuaciones.

La operación para resolver cualquier sistema lineal, es decir de primer grado, con matrices queda descrita con la expresión:

A X=B

A−1 A X= A−1 BX= A−1 B

La matriz A es una matriz que almacena cada uno de los indices de cada incógnita por filas. Mientras que la matriz B almacena los resultados del sistema.

Por ejemplo el sistema:

{a1 x+a4 y+a7 z=b1

a2 x+a5 y+a8 z=b2

a3 x+a6 y+a9 z=b3| se puede representar como A=[a1 a4 a7

a2 a5 a8

a3 a6 a9] y B como [b1

b2

b3]

Entonces, nuestro problema se basa únicamente en encontrar la matriz inversa de A. El método que utilizaré esta basado en la regla de Cramer. No explicaremos extensamente la regla de Cramer, pero como demostración rápida aplicando las propiedades de los determinantes y asignando el valor A1, A2, … a cada columna de la matriz A podemos escribir la siguiente expresión:

det (B1, y A2, z A3)=det (x A1+ y A2+z A3, y A2, z A3)=det( xA1 , yA2 , zA3)→y×z×det(B1, A2, A3)=x× y×z×det ( A1 , A2 , A3)→

x=det (B1, A2 , A3)det( A1 , A2, A3)

Pág. 23

Calculadora Programable Matrices

Desarrollando para B igual a la primera columna de la matriz identidad podemos encontrar la matriz inversa. No terminaremos de concluir con la explicación pero podemos llegar a la matriz inversa con la fórmula general de:

A−1=1

|A|∗Adj ( A)t

Las matrices van más allá y tendrán una última utilidad adicional en la calculadora. Las matrices nos servirán para ayudar a dibujar gráficos.

Matrices y coordenadas en el espacioUno de los principales objetivos a cumplir por la calculadora es la representación de funciones en una gráfica. Para representar una función en una gráfica, normalmente se le asigna a cada punto en la recta de abscisas el resultado de f(x) en el eje de coordenadas. De esta forma obtenemos puntos cartesianos.Si queremos cambiar la escala de la gráfica, tan solo hay que multiplicar las coordenadas por un número. De la misma manera, si queremos mover la gráfica hacia la izquierda o hacia la derecha, tan solo hay que restar o sumar un número a la posición en x del eje de abscisas. Pero, ¿qué sucede en el caso de que queramos rotar la gráfica? A diferencia de antes, en este caso no podemos hacerlo con un sola operación. Para hacerlo hay aplicar a cada punto los teoremas de suma de ángulos. Esto es extremadamente lento y ineficiente, ya que cada vez que rotamos un punto tenemos que calcular varios senos y varios cosenos. Estas son las expresiones que obtenemos para cada punto:

sen (a+b)=sen(a)cos (b)+sen(b)cos (a) y cos(a+b)=cos(a)cos (b)−sen(a)sen(b)

Sin embargo, existe otra forma de hacer las tres cosas, mover, escalar y rotar, en un solo proceso.Para ello, introducimos el concepto de transformación geométrica. Como encierra su nombre, una transformación “transforma” el espacio geométrico en uno nuevo. En vez de pensar en trasladar, rotar y escalar cada uno de los puntos uno a uno, transformamos el espacio primero y luego obtenemos la posición de los viejos puntos en el nuevo sistema. Citando a Futurama de Matt Groening:

El motor no mueve la nave. La nave se queda donde está y los motores mueven el universo a su alrededor.

En esta ocasión, utilizaremos una transformación lineal. Las reglas de la transformación lineal son simples:

• El punto 0,0 tiene que seguir siendo el mismo después de aplicar una transformación.

• Todas las líneas paralelas entre sí tendrán que seguir siéndolo después de aplicar la transformación.

Pág. 24


La Figura.1 nos muestra una transformación lineal de una cuadrícula. La Figura.2 no es una transformación lineal pues las rectas que eran paralelas en la cuadrícula han dejado de serlo.

La clave para transformar el espacio es cambiar el sistema de referencia. En realidad, cuando hablamos del vector P⃗(1,3) estamos hablando de la suma de un vector multiplicado por un número más otro vector multiplicado por otro número. P⃗=1 i⃗ +3 j⃗

Tanto i⃗ como j⃗ son vectores unitarios perpendiculares de longitud igual a uno. Pero, si alteramos el espacio geométrico de manera lineal, los vectores unitarios pasan a tener un nuevo valor dependiendo de la nueva perspectiva. Esto significa que si transformamos únicamente los vectores unitarios, tendremos una buena medida de la nueva forma del espacio, ya que el resto de puntos seguirá compuesto de la misma suma de los vectores unitarios. En resumen, obteniendo los vectores unitarios vistos desde la nueva perspectiva geométrica, podemos computar la misma suma de vectores

P⃗=1 i⃗ +3 j⃗ obteniendo el mismo punto en la nueva transformación.Si nos fijamos bien en la definición de multiplicación de matriz, esto es exactamente lo que hacemos cuando multiplicamos una matriz A y un vector x⃗ . Esto es así porque la matriz A está compuesta por dos columnas cada una conteniendo al vector unitario i⃗ y j⃗ .Obtener la matriz de rotación es sencillo, atendiendo a este diagrama:

El vector i⃗ esta formado por [cos (a)sen(a)] y el vector j⃗ esta formado por [−sen (a)

cos (a) ]Para representar todo en una matriz transformación, juntamos i⃗ y j⃗ en la matriz A

A=[cos (a) −sen(a)sen (a) cos(a) ]

Ahora que tenemos la matriz transformación rotada, podemos escalarla multiplicando el primer o el segundo vector por cualquier número. Para obtener la posición relativa de un punto en la nueva

Pág. 25


perspectiva, tan solo hay que multiplicar la matriz por el punto. En la calculadora, en vez de tratar con matrices de dos dimensiones, tratamos con matrices de tres. Esto permite dibujar proyecciones de puntos tridimensionales en un plano bidimensional. Además, dividiendo la coordenada x y la y entre la z, podemos obtener una imagen en perspectiva cónica de objetos en tres dimensiones, tal y como lo ven nuestros ojos.En conclusión, utilizando matrices simplificamos notablemente todas los operaciones necesarias para representar puntos en un plano. Juntando esto con lo que ya hemos conseguido, tenemos un intérprete matemático y una manera de representar funciones. Sin embargo, aún estamos encerrados en una consola de comandos. Es ahora cuando nos tenemos que plantear un nuevo problema un tanto más artístico y creativo. ¿Cómo organizamos los datos presentados por nuestro interprete matemático para poder verlos de forma visual?

Humanizando las fórmulasA la hora de forjar un nuevo mecanismo, no podemos olvidar que la tecnología ha ido siempre de la mano del hombre. Sería idílico plantearnos la realidad como una ciudad donde hasta el más necio de los habitantes supiera integrar. La tecnología no es nada sin una intuición que la acompañe, algo que permita a los seres humanos comunicarse con una máquina. Por eso, es casi tan importante crear ese vínculo que la propia máquina.

Empecemos hablando de sentidos. A fin de cuentas, con ellos nos desenvolvemos en el medio. De todos, tenemos que decidir cuáles vamos a usar para plantear la información que procese nuestra calculadora. Parece algo muy sencillo; las matemáticas se escriben y se leen, por tanto han de comunicarse solo de manera visual. Sin embargo, pensar esto es caer en una leve errata lógica o como dirían algunos expertos del tema, un neuromito. Las últimas investigaciones sugieren que en nuestra mente, las matemáticas no se organizan única y exclusivamente en números, sino que se pueden y deben afrontar desde distintos puntos de vista, de manera auditiva, visual, táctil… Francisco Mora, un importante neurocientífico propone que un conocimiento no solo se ha de plantear o enseñar de una forma*; cuantas más maneras y recursos tengamos para representar algo en nuestra mente, más sencillo será ésto de entender y por tanto de utilizar. Entonces, está claro que representar las matemáticas como algo meramente numérico es un error que podría conducir a una imposibilidad de su uso. Del mismo modo que para entender problemas matemáticos usamos dibujos, esquemas y bocetos, es fundamental que nuestra calculadora sea capaz de representar los números de otra forma. Existen muchos métodos de representar una ecuación matemática. Podemos representarla de forma auditiva. Por presentar un ejemplo, asignando una frecuencia a un valor determinado, ej. frecuencia = 440x + 440, somos capaces de crear un tono melódico que sin duda vamos a reconocer como una escala de frecuencia completa, de La Octava prima a La Octava segunda. Sin embargo, todos estos métodos son específicos de cada función analizada. Muchas funciones serían muy difíciles de analizar a fondo usando solo un sonido. * Neuroeducación, de Francisco Mora pág. 135

Pág. 26

Calculadora Programable Humanizando las fórmulas

Sin lugar a dudas, el método más habitual es el visual. Representando las matemáticas de una forma geométrica no solo nos extiende el entendimiento de estas a algo más que una serie de reglas numéricas, sino que nos permite visualizar conceptos como la velocidad de crecimiento de una función o la imagen, en una sola pasada. Es por esto que nuestra calculadora presentará un mecanismo de representación visual, en este caso algo conocido como pantalla.

PantallaPese a que en nuestra época parece algo de uso general, las pantallas son todo un desafío tecnológico. La idea es sencilla. Una pantalla consiste en un plano capaz de mostrar cualquier tipo de imagen. Esto significa que una pantalla trabajará tan solo en dos dimensiones. Las pantallas se valen de una idea fundamental para conseguir dibujar cosas en un plano: la interpolación. En vez de controlar todos y cada uno de los haces de luz que desembocan en nuestras retinas oculares, las pantallas simplifican la infinidad de puntos de un plano a una sucesión de cuadrados. Como el ojo humano no es capaz de distinguir formas a partir de cierta distancia, si los cuadrados son lo suficientemente pequeños o están muy alejados, se puede presentar la ilusión de ver una imagen continua. A estos cuadrados se les denomina por lo general como píxeles.Estos píxeles pueden estar organizados de distintas formas. Los podemos unir de tal manera que formen una circunferencia, un óvalo, un triángulo o cualquier forma que este encerrada en un plano bidimensional. Aún así, lo más lógico es que los píxeles se unan formando un rectángulo. El hecho de estar organizados en forma de rectángulo permite un mayor aprovechamiento del espacio. También simplifica mucho el control de las pantallas. Aunque se trate de una pantalla rectangular, aún no sabemos cuál es la forma de esta. Los rectángulos se forman por dos valores principales. La longitud de un lado, que podemos llamar la anchura, y la longitud de un lado contiguo, que designaremos como altura. Para saber cuál es la mejor forma de representar matemáticas no nos importa tanto el tamaño de la pantalla. Sabemos que la máquina ha de ser portable, por lo que buscaremos un tamaño constante que sea cómodo de manejar con las manos. Lo importante para determinar la forma radica en el cociente de la anchura entre la altura de la pantalla. A esta proporción la denominaremos como relación del aspecto. La relación del aspecto es muy importante pues será la encargada de cuadrar todas las gráficas mostradas en la calculadora en un plano reducido. Las relaciones estándar de la industria para estos usos son 1:1, 2:1 y 3:1.

De una forma o de otra, la calculadora va a tener que ser capaz de representar texto. Usando esto como criterio principal podemos decidir cual de las tres relaciones de aspecto es la mejor. Dado que la pantalla además tiene que mostrar distintas imágenes y gráficos, es necesario que la visión útil del usuario abarque el máximo espacio en el plano. El sentido de la lectura en su magnitud vertical va desde arriba hacia abajo. Por lo general, cuando en un texto predomina la lectura en forma horizontal, se vuelve largo y difícil de leer. Además, es mucho más sencillo perderse. Sin embargo, cuando los artículos están encolumnados y usan oraciones cortas resulta muy fácil leerlos. Este es el motivo principal por el cual la relación al aspecto 1:3 es demasiado horizontal.

Pág. 27

1:1 2:1 3:1


Con la 1:3 descartada solo queda elegir entre 2:1 y 1:1Las definiciones 2:1 y 1:1 son muy parecidas a las definiciones de HD, con una relación al aspecto de 16:9, y NTSC convencional, con relación 4:3, respectivamente. Aunque hace unos años ambas definiciones eran totalmente competentes, últimamente con la introducción de los teléfonos inteligentes y pantallas de alta definición, parece ser que la balanza se ha inclinado favoreciendo a la relación 16:9. Por supuesto, esto se debe a la visión humana que consta de dos ojos colocados en horizontal. Esta disposición hace que nuestra visión no sea únicamente circular, sino que más bien es ovalada. Si comparamos la cantidad de superficie en un óvalo que cubre un rectángulo con la que cubre un cuadrado, podemos ver serias diferencias dónde el rectángulo sale favorecido. Por estos motivos elegiremos la relación 2:1.Lo siguiente a tener en cuenta a la hora de elegir una pantalla es el número de píxeles con los que vamos a trabajar. Como se ha descrito anteriormente, la acumulación de cuadrados muy pequeños engaña al ojo y le hace pensar que está viendo una imagen continua. Aún así, si estas celdas son demasiado grandes, se vuelve mucho más complicado que la ilusión se produzca. Si pudiésemos, la pantalla se compondría de la mayor cantidad de píxeles con el fin de poder representar imágenes completamente nítidas. El problema consiste en el número de píxeles. Todavía no entraremos en detalles, pero, cuanto más cantidad haya de ellos, más carga tendrá el procesador.

La cantidad de píxeles en una pantalla viene determinada por la multiplicación de la anchura × la altura.

N.º de píxeles = anchura × altura h

(x+h)×( y+h)−x× y=Δ Áreay

Δ Área=x×h+ y×h+h2=(x+ y)×h+h2

x h Es importante tener en cuenta esta formula, pues significa que la cantidad

de píxeles que hay en una pantalla no es directamente proporcional al tamaño de la altura y anchura, sino que aumentará cuadráticamente.

La pantalla ha de tener la menor resolución posible manteniendo la capacidad de mostrar texto. Existen infinidad de opciones disponibles pero normalmente estas pantallas suelen tener en sus cifras números potencia de 2. En resumen, las definiciones disponibles son: 32x16, 64x32, 128x64 y 256x128.

Imagen 2: definición 16x32


Pág. 28

Tanto en la imagen 1 como en la 2 apenas se pueden distinguir las letras y números. Los píxeles son totalmente perceptibles en la primera. Tal vez con un tipo de letra más ajustado a bajas definiciones podríamos obtener un resultado mejor, pero a simple vista se observa su deficiencia gráfica.




Las imágenes 1,..,4 representan aproximadamente como quedará el texto a diferentes resoluciones.Siguiendo con la regla anterior, hay que recordar que cada pantalla tiene cuatro veces la cantidad de píxeles que la anterior. Las imágenes 1 y 2 quedan descartadas por ser ininteligibles. La definición de la imagen 4 es sin duda la que mejor se ve, adaptándose completamente a las necesidades de una calculadora convencional. Sin embargo, la carga de píxeles es demasiado alta. Teniendo que tratar con 32768 píxeles cada vez que queramos cambiar el contenido de la pantalla. En definitiva, la pantalla 3 presenta unas propiedades mucho más atractivas, siendo el texto casi tan legible como la 4 por un cuarto del coste.En cuanto al color, la pantalla será monocromática, es decir, de un solo color. Para la utilidad que le vamos a dar, el color, aunque curioso, es innecesario. Además, por motivos que explicaremos más adelante, el color es un recurso costoso.Esta será la definición que trataremos en general durante todo el proyecto. Todo lo que haga la calculadora tendrá que poder mostrarse en una superficie de 128 x 64.

GráficosEl ser humano lleva estudiando el arte gráfico desde tiempos inmemoriales. Muchos artistas han dedicado su vida a buscar todos los procesos que nos ayuden a plasmar una idea visual en un plano o en un modelo. Pero pese a la longeva vida de la pintura, ninguno de estos conocimientos se puede englobar en el mundo de la matemática, al menos ésta era la situación a la que se enfrentaron los científicos allá por los años cincuenta. Gracias a un inmenso crecimiento por el interés de este arte, en menos de medio siglo se han descrito métodos que permiten representar auténticas imágenes fotorrealistas. Para conseguir representar gráficas, formas geométricas, e incluso texto, hay que enfrentarse primero a una serie de problemas fundamentales.

Naturaleza de los píxelesEl primer problema al que nos enfrentamos son los ya conocidos píxeles. Hasta ahora, todo lo que sabemos de ellos es que están dispuestos en un rectángulo bidimensional con una altura y una anchura. A este plano le llamaremos con el nombre de lienzo.También sabemos que son monocromáticos, es decir que solo tienen un color; aunque más concretamente tienen dos estados, apagado o encendido. Podemos entonces tratar a un píxel como a un número binario. Este será igual a cero cuando esté apagado y a uno cuando esté encendido.

Pág. 29

En el caso de la imagen 3 todavía podemos percibir ligeramente los píxeles mientras que en la 4 son invisibles. Aún así en ambas se puede leer claramente el texto de prueba.

Calculadora Programable Gráficos

Por último, es importante mencionar que los píxeles disponen de una posición. La posición en el plano viene determinada por un número en el eje de abscisas que llamaremos x, y un número en el eje de ordenadas que designaremos con la letra y. Todos los valores de los píxeles, valor, posición y lienzo, deberán ser fácilmente accesibles en todo momento de una forma rápida. Entonces, el problema radica en conseguir un método para organizar los píxeles.La estructura de datos planteada en este proyecto es en realidad muy simple. Definitivamente, la forma más eficiente de guardar la información de los píxeles es en forma de lista. En esta lista guardaremos el valor de cada píxel en orden. Para lograr esto, la memoria estará formada por la concatenación de todas las filas presentes en el lienzo. Estas filas estarán colocadas en orden siendo la primera, la fila en la que el valor de y de los píxeles sea 0.

[a0 a1 ... an

b0 b1 ... an

c0 c1 ... cn

... ... ... ...]→ a0 , a1,…, an ∘ b0 , b1,…, bn ∘ c0 , c1, …, cn ∘ …

El único problema es que al pasar de una unión de valores en dos dimensiones a una única dimensión hemos perdido la información de la posición. Para recuperarla, nos ayudaremos de las medidas de nuestro lienzo, más concretamente de la anchura. Para recuperar la coordenada y, nos bastará con dividir el valor i que ocupa en nuestra lista unidimensional entre el valor w de la anchura del lienzo. Para la coordenada x, volveremos a dividir i entre w, pero esta vez tan solo tendremos en cuenta el resto. En resumen, para obtener las coordenadas de un punto a partir de su posición en una lista unidimensional usamos:

p⃗ = (x=i mod w∗ i⃗ y=iw

∗ j⃗ )En caso de querer pasar de coordenada a valor en la lista, multiplicamos el valor de y por la anchura, w, y le sumamos el valor de x.

i= y∗w+x

Con este par de expresiones definimos una manera sencilla de movernos de la posición unidimensional a la coordenada y viceversa. Con estas reglas, nuestra lista tiene un tamaño equivalente a multiplicar la anchura por la altura, w * h. Además, tenemos que guardar el valor de w para poder acceder a la posición de los píxeles más tarde. En total, la pantalla gastará de entrada unos preciados 128 * 64 = 8192 valores. Para traducir esto en unidades más internacionales, introduzco el término bit como medida equivalente a un valor. Es decir, un bit puede guardar dos números: el 0 y el 1. Entonces, la pantalla ocupará 8192 bits como mínimo. Sin embargo, los procesadores no trabajan directamente con esta unidad. En su lugar, trabajan con la medida byte que equivale a ocho bits juntos. Con esto en

Pág. 30


mente, a no ser que hagamos algo, el lienzo ocupará 8192 bytes, lo cual es una cantidad demasiado grande. Para evitar gastar información inútilmente, intentaremos que el procesador maneje las operaciones con bits. Esto afectará al tiempo de ejecución del programa, pero reducirá el espacio utilizado a un octavo. En caso de que los píxeles tuvieran tan solo un color, en vez de dos valores, 0 y 1, tendrían que guardar un valor por cada color. Si quisiéramos 256 colores, eso significa que cada píxel ocuparía 8 bits, un byte. Y esto es solo con 256 colores! Los ordenadores de hoy en día trabajan con 32 bits por píxel. Es decir, son capaces de mostrar imágenes con hasta 4.200 millones de colores.

Operadores en ImágenesAhora que queda claro cómo se presenta la información gráfica, tenemos qué definir que vamos a hacer con ésta. Las operaciones básicas con imágenes van a ser: dibujar una imagen por encima de otra; borrar una parte concreta del lienzo; y por último invertir los píxeles de una imagen en el lienzo. Estas operaciones tienen una correspondencia con las operaciones binarias lógicas.

Aplicar un operador a una imagen, significa que aplicamos el operador a cada uno de los píxeles.

Borrar una parte concreta del lienzo

Dibujar una imagen en el lienzo

Invertir el lienzo o la imagen

Pág. 31

& =

Al aplicar el operador de la conjunción con una imagen vacía, da igual lo que esté presente en la primera imagen ya que siempre será falso.

OR =

En este caso aplicamos el operador de la disyunción. De esta forma, conseguimos que ambas imágenes queden superpuestas una encima de la otra.

¬ =

Para invertir la imagen usamos el operador de la negación.


Dibujando LíneasProbablemente, en un plano bidimensional, la figura más importante es la recta. Esto se debe a que la recta es la única capaz de, uniéndose a otras, crear todas las figuras del plano.

El método más sencillo para definir una recta queda representado con la ecuación vectorial.

(x , y ) = ( p1, p2) + λ (d1, d2) → De esta expresión, podemos derivar a la expresión de doble punto.(x , y) = (a1, a2) + λ(b1−a1, b2−a1)

y=(b2−a2)(b1−a1)

∗(x−a1)+a2

Con intención de simplificarla, podemos expresar una recta de la siguiente forma:Δ x=b1−a1, Δ y=b2−a2

B=a2−Δ yΔ x

∗a1

y=Δ xΔ y

∗x+B

(Δ x ) y=(Δ y) x+(Δ x )B

Para dibujar una recta con esta expresión, no tendríamos más que calcular la y para cada valor de x. Sin embargo, en nuestra pantalla nos encontramos con un problema bastante significativo: la interpolación.

Una recta real está constituida por infinitos puntos. Sin embargo, en nuestro sistema solo va a poder representarse como una sucesión de píxeles definida.

Para ejemplificar, calcularemos los valores de y de la recta que se forma con los pts. A=(0, 0) y B=(5,10) . Aplicando la ecuación de doble punto obtenemos que y

vale 0, 2, 4, 6, 8 y 10 para cada x respectivamente. Si nos fijamos en la Figura.4 vemos claramente un salto de nivel para cada x. Esto se debe principalmente a que la pendiente de la recta es mayor que 1. En estos casos, hay más distancia en el eje de ordenadas que en el de abscisas. Atendiendo a la pendiente, m, podemos diferenciar hasta 4 casos distintos:

• m>0∪m≤1

• m>1

• m≤0∪m≤−1

• m<−1

Para simplificar, únicamente valoraremos el método de resolución del primer caso.

Pág. 32


Existen cuatro casos más consistentes en que el punto B esté más a la izq. que el punto A, pero no los trataré en esta ocasión.

Otro de los problemas presentes a la hora de definir un método de dibujo de rectas está relacionado con la estandarización. No se obtiene el mismo resultado si se valora que los píxeles coloreados sean todos aquellos por los que pase la recta Figura.5, que si se valoran los coloreados como los más cercanos al punto de corte de la recta con el vértice anterior. Dado que para una pantalla pequeña el primer método queda algo grotesco, hemos tomado la decisión de elegir el segundo método como el más elegante para el proyecto.

Algoritmo de BresenhamPor supuesto, para empezar a dibujar la línea, sabemos que el primer punto corresponderá con (a1, a2) y por consiguiente, el último será (b1, b2) . Dado que estamos analizando el caso en que la pendiente de la recta sea menor que uno y mayor que cero, sabemos que cada vez que aumente x un punto; y aumentará un valor comprendido entre el 0 y el 1.Tal vez, intuitivamente, es razonable que consideremos aumentar un píxel de altura cuando la recta pase por encima del vértice del píxel anterior tal y como se muestra en la Figura.6

Por lo tanto, buscamos saber cuál es el valor de la y en x + ½. Usando la ecuación de la recta:

yx +1/ 2 = m(x+1/2)+n → mx+m(1/2)+n

Dependiendo del valor de y, aumentaremos una posición verticalmente si ésta es mayor que 1+1/2. En caso contrario, no aumentaremos.Aunque esta expresión ya es funcional, es un tanto lenta todavía. Para simplificarla a un método recursivo, sacamos la distancia de un punto al siguiente.Asumiendo que ya hemos calculado el primer punto, esta es la expresión de la diferencia cada vez que aumentamos un píxel: D=m(x+1+1/2)+n−(mx+m(1 /2)+n)→ D=m

Con ésto, concluimos que cada vez que aumentemos un píxel, el valor y aumentará m.En resumen, ésta sería la implementación del algoritmo en pseudocódigo:

función dibujar_línea(p1, p2):

flotante deltax = p2.x – p1.x

flotante deltay = p2.y – p1.y

flotante m = deltay / deltax // Obtenemos la pendiente con decimales

flotante error = 0.0

entero y = 0

Pág. 33


para cada x desde p1.x hasta p2.x:

dibujar un píxel en (x , y)

error = error + m // Sumamos m

si ( error >= 0.5 ) entonces: // En el caso primero, suponiendo que empezamos en el p.x, p.y

y = y + 1

error = error – 1 // Restamos uno a error para dejarlo a un punto de distancia del siguiente vértice

Aunque este algoritmo es funcional, su velocidad es relativamente baja. Los cálculos con números decimales son mucho más pesados que los de enteros. Además, la división del principio nos va a llevar a un pequeño error cometido.

Algoritmo de Bresenham (Con números enteros)Si retomamos la expresión del principio,

(Δ x ) y=(Δ y) x+(Δ x )B

es fácil darse cuenta que en este caso hemos multiplicado todo y = mx + n por Δx. Comprobando el valor de x+1 frente a x,

D=(Δ y )(x+1)+(Δ x) B−((Δ y) x+(Δ x)B)→D=Δ y

demostramos que en vez de la pendiente, por cada x + 1, (Δx)y aumenta Δy.Si en vez de aumentar 1, aumentamos Δx, y incrementa Δy. Teniendo clara esta proporcionalidad podemos llegar al siguiente punto, ese ½ utilizado en el algoritmo decimal.La expresión general sería:

(Δ x ) y=Δy2

+Δ y+Δ y .. .

Para evitar tratar con ½ multiplicamos la expresión por dos: 2(Δ x ) y=Δ y+2Δ y+2Δ y .. .

Como cada vez que aumentamos Δx la y crece Δy, para saber si excede o no el siguiente vértice, valoramos 1/2 Δx. Dado que hemos multiplicado la expresión por dos, tan solo valoramos Δx.

En resumen, el pseudocódigo tendría este aspecto:

función dibujar_línea_enteros(p1, p2):

entero deltax = p2.x – p1.x

entero deltay = p2.y – p1.y

entero error = 2*deltay

entero y = 0

Pág. 34


para cada x desde p1.x hasta p2.x:

dibujar un píxel en (x , y)

si ( error >= deltax ) entonces: // En el caso primero, suponiendo que empezamos en el p.x, p.y

y = y + 1

error = error – 2*deltax

error = error + 2*deltay // Sumamos m

Dibujando CircunferenciasEn el proyecto también incluiré un método para la realización de circunferencias. Como bien sabemos, una circunferencia queda definida por el teorema de Pitágoras de la siguiente forma:

r ²=x ²+ y ²Con esta expresión podemos determinar la y en función de la x. Sin embargo, si en las rectas ya era algo lento multiplicar por la pendiente, en este proceso tenemos que realizar una raíz cuadrada de una resta de cuadrados lo cual es algo extremadamente costoso.Usando una serie de optimizaciones matemáticas, podemos reducir las operaciones a únicamente sumas y restas.Para empezar, dividiremos una circunferencia en 8 octetos. Simétricos entre sí, reducirán en ⅛ la tarea.

Con esto, podemos determinar que en el octeto, el valor de y siempre va a ser menor al valor de x. En caso de ser y mayor sabremos que hemos terminado de dibujar el octeto.Para dibujar el resto, lo que haremos será rotar el vector de posición y colocarlo en el punto correspondiente a cada octeto.

Por ejemplo, para el 2º octeto, el punto base sería O⃗2=(0,R) ; y la

matriz de rotación: [ 0 1−1 0]

El siguiente paso para optimizar el algoritmo consiste en obtener la diferencia entre x y x-1; como en el caso del dibujo de rectas. En este caso avanzaremos de y = 0, hacia y = R*sqrt(2)

r ²=x2+ y2→ y ²=r ²−x ²r ²−x ²−(r ²−(x−1) ²)=2 x−1

Es decir, la diferencia entre ( y x−1) ² y yx ² es de 2x-1 Además, si empezamos en x = R

2(r−x)−1=2r−2 x−1

Ahora ya podemos saber la posición de y² en cada x sumando progresivamente desde x = 0

Pág. 35


2r -2x – 1. El problema es que hablamos de y² y no de y. En este punto podemos hacer dos cosas, o bien calculamos la raíz cuadrada de y² o, al contrario, calcular el valor de la y temporal al cuadrado.Dado que el cuadrado de un número se puede computar velozmente de forma recursiva, optaré por esa opción. La expresión para calcular el cuadrado de un número viene dada por:

y=x2

yx+1− yx=D(x+1) ²−x ²=2 x+1=D

En resumen, éste es el pseudocódigo:

Función dibujar_circunferencia(x0, y0, radio )

entero x = radio-1;

entero y = 0;

entero dx = 1; // Guardará el valor de 2*x anterior

entero dy = 1; // Guardará el valor del cuadrado anterior

entero error = dx - 2 * radio // Si en vez de sumarlo, lo restamos compararemos con 0.

Siempre que x >= y

{

dibujar un píxel en x0 + x, y0 + y

dibujar un píxel en x0 + y, y0 + x

dibujar un píxel en x0 - y, y0 + x

dibujar un píxel en x0 - x, y0 + y

dibujar un píxel en x0 - x, y0 - y

dibujar un píxel en x0 - y, y0 - x

dibujar un píxel en x0 + y, y0 - x

dibujar un píxel en x0 + x, y0 - y

Si error <= 0 // En caso de que la y temporal no supere la posición de y en x

{

y = y + 1

error = error + dy // Sumamos a error el cuadrado actual

dy = dy + 2 // Sumamos al cuadrado actual el mismo más dos, así calculamos el siguiente

}

Si error > 0

{

x = x - 1;

dx = dx + 2; // Cumplimos con 2r – 2x -1

error = error + dx - 2 * radio;

}

}

Pág. 36


A partir de la recta…Para aclarar: a partir de la recta, el usuario podría dibujar cualquier figura poligonal. Para ello, partiendo de sus vértices indexados podemos dibujar el polígono deseado.

Tal y como se muestra en la Figura 7. acompañamos a cada línea con la información de los vértices por los que pasa. El inconveniente de usar índices es que ahora la memoria tiene que guardar los puntos junto con los índices. Por esta razón, en figuras como el rectángulo o triángulo será mejor utilizar un método específico.

Rellenar formas con un color determinado.Para completar el repertorio de posibilidades de representación gráfica, es indispensable el uso de la función rellenar. Existen distintas maneras de enfrentarse a este problema. Pero el método más conveniente es el relleno con escaneo de líneas.

Dada una figura y un punto, el algoritmo ha de ser capaz de rellenar todas las celdas vacías sin atravesar ninguna “pared” previa. Aunque la tarea puede parecer muy sencilla, lo cierto es que conseguir resolverlo de forma eficiente y correcta no lo es tanto. Como su nombre indica, el algoritmo de escaneo de líneas se dedica a primero a rellenar una línea y después escanear posibles líneas colindantes. En caso de encontrar alguna, la línea encontrada será igualmente rellenada y escaneada buscando posibles colindantes. El proceso se repetirá hasta que ya no se encuentren líneas colindantes.

Pág. 37


Dado el punto a, en el primer paso escaneamos la línea. Para escanear la línea avanzamos posiciones en ambas direcciones hasta encontrar un píxel que corte. Una vez rastreada la línea, se rellena.

Figura 12.

El segundo paso consiste en buscar líneas colindantes. Estas líneas se encuentran encima y debajo. Así que, en cuanto encontramos un píxel libre, repetimos el paso uno en esa recta recién encontrada.

Figura 14.

Por último, las líneas colindantes volverán a repetir el proceso, rellenándose y buscando nuevas líneas colindantes. En caso de no haber ninguna, el proceso parará indicando que se ha rellenado completamente la forma. Figura 15.

ImágenesPero, ¿qué pasa si queremos dibujar formas complejas que requieran una gran cantidad de líneas y circunferencias? ¿Qué pasa si queremos dibujar algo que no sea sencillo de generar como los caracteres de las letras, o los iconos de cada acción? Para estos casos, lo mejor es guardar la información de sus píxeles ya generada en algún sitio. A este tipo de datos le llamaremos imágenes puesto que no nos dicen nada a cerca de las formas que representan, si no que solo nos dan la información de sus píxeles. Las imágenes realmente tendrán la misma forma que el lienzo, es decir estarán compuestas de una lista de puntos. La única diferencia radica en que las imágenes necesitan un valor más, la posición en la que van a dibujarse en un plano.Presentarlas en pantalla es sencillo. Tal y como se explicó anteriormente, tan solo hay que operar con la disyunción de tal forma que obtengamos una superpuesta de la otra. En general, el verdadero problema es el de como crear las imágenes. Por suerte, existen infinidad de herramientas de código abierto ya creadas para simplificar este proceso. Más adelante hablaremos sobre en que consiste el proceso. Lo interesante de las imágenes, es que con ellas podemos al fin empezar a dibujar texto. Además de texto, nos servirá para poder dibujar iconos, símbolos y demás que ayudarán al usuario a manejarse por la calculadora. Entonces, las imágenes tendrán un uso más dedicado a un tema de estética que técnico, aunque eso no evita que sean igualmente importantes.

Pág. 38

Calculadora Programable Imágenes

LetrasAún desconocemos cuándo o dónde el ser humano descubrió la escritura con exactitud. Lo que si que es indiscutible es el gran poder que nos brindó tal descubrimiento. Gracias a él, podemos representar conocimientos complejos y abstractos utilizando tan solo una serie de símbolos unidos entre sí. Si bien la invención de los números fue un gran avance para las matemáticas, inventar la escritura garantizó un rápido avance no solo para el lenguaje sino para todo el conocimiento humano. En una calculadora es imprescindible el uso de texto. De esta forma el usuario, que asumimos sabe leer, será capaz de entender los resultados planteados sin conocimiento previo.A diferencia con las expresiones matemáticas, en esta ocasión tenemos el objetivo de plantear texto y no de leerlo o entenderlo.Las reglas de la escritura occidental establecen fundamentalmente que:

• La escritura se lee y se escribe de izquierda a derecha y de arriba a abajo.

• Aunque cada letra puede tener variantes, todas y cada una de ellas tienen un símbolo único y no se combinan entre sí.

• Las palabras se separan con un espacio en blanco.

Con estas bases, podemos empezar a plantear la escritura de texto.Dado que hay un número concreto de caracteres en todos los idiomas, podemos empezar por asignarle a cada letra un valor. Por ejemplo la A pasa a valer 1, y la B pasa a valer 2. En realidad, usaremos un estándar para esto, el conocido como código ASCII. En el código ASCII, la A tiene un valor de 65. Es importante apuntar que dado que A y a tienen distintos símbolos, en nuestro código serán dos cifras diferentes. Además, el espacio será considerado un carácter más.Para formar texto, lo único que haremos será concatenar los códigos de las letras en una lista. Para poder modificar la lista, podremos introducir un caracter en un punto concreto, borrar un caracter determinado y concatenar dos textos. Ahora que está clara la forma de tratar con el texto en el sistema, nos queda hablar sobre el segundo paso, que es mostrarlo al usuario. Para conseguirlo, utilizaremos algo llamado como fuente tipográfica. Las fuentes guardan la imagen del símbolo de cada letra. Si colocamos el símbolo correspondiente a todas las letras de un texto, podremos “dibujar” el texto en pantalla de tal manera que el usuario pueda leerlo.

Si cambiamos la fuente, podemos atender a distintas tipografías, por ejemplo, con una fuente más pequeña, el texto se puede ver más pequeño. O podemos conseguir que una parte del texto resalte dibujándolo más oscuro y grande que de costumbre. En resumen, a mayor cantidad de fuentes, dispondremos de más versatilidad. Sin embargo, hay que recordar que cada fuente ocupará espacio en memoria por lo que conviene utilizar la menor cantidad de ellas posibles.Fundamentalmente haremos uso de dos fuentes principales:

• Una de tamaño grande para textos claros como el resultado de una operación

Pág. 39

Calculadora Programable Imágenes

• Otra de tamaño pequeño que sirva para plantear todos los elementos presentes en la pantalla secundarios, como por ejemplo las escalas de los ejes de coordenadas o los exponentes de los números.

Interfaz de UsuarioDel mismo modo que un autocar necesita un volante para poder ser controlado, la calculadora necesitará elementos que pueda controlar el usuario. A través de estos elementos, el usuario entenderá el estado de la máquina y será capaz de configurarla.Entre los elementos de control que incorporara la calculadora están:

• Texto desplazable.

Este elemento es similar a un texto normal, sin embargo, tiene la habilidad de moverse por unos bordes concretos permitiendo que el texto quede siempre visible.

• Botón con imagen.

El botón con imagen consiste simplemente en un cuadrado que se puede seleccionar.En caso de estar seleccionado cambiará de imagen, si no lo está mantendrá su forma original.

• Botón con texto.

El botón con texto mantendrá la dinámica de selección con la diferencia de que en vez de una imagen cualquiera colocaremos un rectángulo con texto en su interior.

• Lista de texto desplazable.

Si unimos textos desplazables colocando uno encima de otro crearemos un texto a modo de párrafo. La lista de texto desplazable hará el papel de un párrafo permitiendo colocar textos muy largos en la calculadora.

Imagen 6

En definitiva, juntando todas los elementos de interfaz de usuario podemos mostrar en pantalla composiciones más desarrolladas como la que vemos en la Imagen.6. Juntando todos los elementos gráficos que se han tratado y el intérprete matemático, se han consolidado todas las bases necesarias para empezar con el diseño de la calculadora.

Pág. 40

Calculadora Programable Diseño Electrónico

Diseño ElectrónicoPor muchos fundamentos teóricos que tengamos sobre aquella cuestión del cálculo, aún nos encontramos desnudos e indefensos ante la posibilidad de una realización física. Pese a que en este proyecto no se tratarán de forma extensiva los principios físicos utilizados, intentaremos desarrollar lo mejor posible el sistema utilizado.

ProcesadorEl cerebro pensante de la calculadora; sin lugar a dudas el procesador es el mecanismo base que llevará a cabo todas las operaciones necesarias. Pero, siguiendo con la analogía del cerebro, necesitaremos un cuerpo que lo mantenga sano y funcional.Para este proyecto la mejor decisión es sin lugar a duda la de elegir un micro controlador.Pese a que al principio los micro controladores tan solo se dedicaban a unir la información comunicada por una CPU con puertos de salida/entrada de información, en las últimas décadas estos pequeños circuitos se han vuelto cada vez más potentes, hasta el punto en el que ya no necesitan de una CPU para controlar los puertos.Los micro controladores incorporarán elementos bases que simplifican parcialmente su programación y uso. De entre todos los micro controladores, he elegido un dsPIC33EP256MC202. El procesador elegido es relativamente rápido y su consumo es reducido. Esto, unido a la alta cantidad de memoria interna y al bajo precio del procesador, hace que sea una de las mejores opciones.El dsPIC33EP funciona a 3.33V y a una frecuencia de reloj interno de hasta 70 Mhz. Es un procesador re-programable con una memoria flash de 256 Kbytes para programas y 32 Kbytes de memoria para la SRAM.Este procesador pertenece a la familia de procesadores de microchip llamada PIC, acrónimo de Programmable Intelligent Computer. Dentro de todos los PIC, es de tipo dsPIC, procesador similar a la familia PIC24 pero especialmente adaptado para trabajar con procesamiento de señales digitales. En realidad, para el propósito de una calculadora, el procesamiento de señales digitales no es fundamental, pero dada la insignificante diferencia de precio me decidí por el dsPIC.

El procesador necesita de una configuración básica para funcionar. Fundamentalmente, dos condensadores para limpiar la señal de posible ruido y una resistencia para activar el pin Master Clear.Normalmente, se recomienda añadir un resonador externo al procesador. Sin embargo, dado que la calculadora no va a necesitar una medida precisa del tiempo, prescindiré de su uso.En resumen, de una forma esquemática, el diseño del circuito base es el qué se ve en la Figura 20El procesador se puede programar en C a través del compilador de Microchip XC. Su arquitectura interna presenta 16 bits a diferencia de los 64 de un ordenador actual. Los principales retos del procesador consisten en adaptar el código para poder ser ejecutado en un procesador tan limitado.

Pág. 41Figura 20


Monitor LCDLa calculadora necesita de una pantalla para mostrar gráficos. En esta ocasión me he decidido por una pantalla que utilice el chip KS0108. Este chip puede controlar una pantalla de 64x64. Así que para controlar una pantalla de 128x64, la pantalla utilizará dos chips.El controlador de la pantalla lo he programado enteramente en C. Esta basado en la descripción de Samsung del chip KS0108. De forma simplificada, esta tabla muestra la disposición de cada pin para cada instrucción:

Lo principal a destacar aquí es la dificultad de cumplir con la tabla de la forma más eficiente. Cada vez que escribimos a la pantalla así como cada vez que leemos información, el procesador tiene que esperar a que la pantalla envíe la instrucción READY en el pin de datos 7.En general este tiempo de espera es la principal causa de la lentitud del driver. Para evitar esto, intentaremos en el driver enviar todos los píxeles de un bloque al mismo tiempo en vez de mandarlos uno por uno. Aunque no es un la solución óptima, haciéndolo así, ahorramos 7 esperas por píxel.En un futuro, se podría escribir el driver en assembly y jugar más con los límites físicos de los tiempos de espera. Por ahora, escribiremos el driver en C por ser un lenguaje más sencillo e intuitivo.Para más información a cerca del funcionamiento de este chip, recomiendamos referirse a la ficha de datos del proveedor.*

*Samsung, KS0108B LCD Driver IC

Pág. 42

Figura 21


CircuitoAhora que ya hemos definido cada elemento, lo único que queda por explicar es el circuito electrónico. Principalmente, incluye las conexiones mínimas para el micro controlador y la línea de datos que lleva la información a la pantalla. El diseño esquemático es el siguiente:

En este esquema hemos diseñado todo utilizando el software libre KiCad. Hemos añadido un pequeño interruptor que controla la corriente. Además, el circuito incluye el chip LD11117V33, un regulador de voltaje de 3.33V tal y como podemos ver en la Figura 22. Existen numerosos métodos para modificar el voltaje de un circuito. Podemos simplemente usar la ley de Ohm. Colocando dos resistencias en serie, podemos dividir el voltaje en dos partes dejando una a la cantidad necesaria. El problema es que este método limita la corriente del circuito. En su lugar, podemos aprovecharnos de las propiedades de un semiconductor como el silicio para reducir el voltaje. Los dos métodos más utilizados son los Convertidores Buck y los Convertidores lineales FET.Los de tipo Buck se aprovechan de un inductor para incrementar o disminuir el voltaje. Alternando entre un circuito donde el inductor aumenta su campo eléctrico y otro en el que la corriente creada por el inductor carga un condensador, se puede modificar el voltaje de salida.

Pág. 43

Figura 22


Este sistema aunque altamente eficiente, produce una señal con mucho ruido. Este ruido es perjudicial y podría ser suficiente para que el procesador no funcionase. Por ello, la segunda opción, los de tipo FET, es la opción más indicada. Los de tipo FET funcionan de manera parecida al divisor de voltaje. Sin embargo, se auto-regulan cambiando los valores de la resistencia en función de el valor de la intensidad que recorre el circuito.

Los conectores nombrados por EXTENSION_PINS servirán para un fácil desarrollo de la placa. Los primeros unen directamente con los pines de información y reloj para programar la memoria interna del procesador. El resto servirán para conectar cualquier extensión a la calculadora.

Por desgracia, debido al tiempo limitado de desarrollo, no he podido llegar a terminar un teclado funcional. Aún así, el usuario puede controlar la calculadora con un teclado estándar conectado a los pines de extensión.

Impresión del Circuito y MontajeCuriosamente, lo único que falta para poder disfrutar de una calculadora, es la calculadora en sí. Hasta ahora hemos hablado y propuesto diseños acerca del funcionamiento de la misma, pero no tenemos nada en el mundo físico.Aunque, ya este propuesto el circuito, falta llevarlo a la realidad. Por suerte, en las últimas décadas y con razón del gran crecimiento tecnológico que hemos sufrido, construir un prototipo preciso y funcional es muy sencillo. En comparación a los métodos lentos y rudimentarios que se usaban antaño, hoy en día existen métodos veloces y casi automáticos. Como bien sabemos todos, cualquier circuito electrónico precisa de raíles por donde pueda circular la corriente eléctrica. Estos raíles, compuestos de un material conductor, conectarán todos los elementos entre sí cerrando el circuito. En circuitos grandes, normalmente se utilizan cables o alambres rodeados de un material aislante como raíles. Sin embargo, cuanto más pequeño es el circuito, se vuelve más complicado usar cables. En su lugar, hoy en día se usan placas electrónicas. Suponiendo que se trata de un circuito simple, las placas electrónicas están compuestas principalmente por tres capas de elementos. Una capa de cobre, o otro metal conductor, y dos capas de un aislante que separen el metal del medio ambiente.El primer proceso que sufre una placa electrónica se llama Atacado. En este proceso, las láminas del metal conductor son introducidas en un ácido corrosivo que elimina el metal innecesario. De esta forma, tan solo serán conductoras las bandas que no toquen el ácido.Una vez la placa metálica esta preparada, esta se pega y se une a dos láminas de un material aislante, normalmente plástico. Dado que en este paso todos los pines y conectores donde van soldados los elementos quedan tapados, será necesaria una fase de perforado. En el perforado una máquina asistida por ordenador hace los agujeros correspondientes volviendo a dejar al descubierto el metal.Por último, normalmente se aplica una capa de estaño a las partes metálicas de la superficie para facilitar la soldadura de componentes. En los diseños finales, se incluye una capa de serigrafía donde aparecen símbolos o texto que indican la posición de los componentes.A día de hoy, este es un proceso industrial y difícilmente se puede realizar de manera doméstica. Aún así, es fácil encontrar empresas que proporcionan pequeñas cantidades de placas impresas a particulares.

Pág. 44


Hemos diseñado la placa utilizando el software libre KiCad. El proceso de diseño consiste en unir todas los elementos y todas las pistas en una capa de cobre. Dado que normalmente es imposible unir todos los componentes en un único plano, son necesarias vías que muevan la corriente a otro plano colocado encima. Para la calculadora hemos utilizado un total de dos planos.

ConclusiónEl proyecto se podría resumir en tres fases principales, la primera de búsqueda de información, la segunda de desarrollo y la tercera de documentación.

Durante la primera etapa dedicamos todos los esfuerzos a buscar todas las herramientas y componentes que fuesen a ser útiles para el prototipo final. Además afianzamos todos los conocimientos necesarios para empezar el desarrollo. Después de investigar y analizar todas y cada una de las incógnitas, bien sea leyendo acerca de un tema o documentándonos con los manuales que facilitan los proveedores; comencamos con el desarrollo de la calculadora.

La segunda fase, de desarrollo, es sin lugar a dudas la más compleja de todas. No solo hemos tenido que escribir cada una de las rutinas de la calculadora sino que también hemos tratado con errores y inconvenientes propios del trabajo de campo. Este hecho ha significado un tremendo enriquecimiento didáctico dónde hemos podido prepararnos para un caso real. Tal vez, la suma de inconvenientes y la alta carga de trabajo que ha supuesto el proyecto, ha limitado en parte la realización de la documentación escrita y ha bajado las expectativas del proyecto inicial.En el primer periodo de esta fase, principalmente dedicamos todo el tiempo en preparar el código y en estructurar el proyecto. Durante este periodo fue necesaria la creación de herramientas de simulación, como el de una pantalla monocromática, y herramientas de apoyo, como un generador de fuentes y de imágenes.

Pág. 45

Calculadora Programable Conclusión

Más tarde, comenzamos a centrarnos en solucionar cada uno de los problemas propuestos hasta tener un programa funcional. Alternando entre desarrollo de los gráficos y desarrollo del intérprete, este es el periodo que más tiempo consumió dejando poco restante para una posible conclusión absoluta de todos los objetivos. Aún así, consideramos que el proyecto ha cumplido con los objetivos mínimos propuestos al inicio, pues al fin y al cabo se trata de una calculadora completamente funcional.Por último, en el desarrollo nos centramos en conseguir hacer funcionar todas las piezas de código y componentes. Esta fase resultó ser más sencilla de lo que se estimaba iba a ser. Lejos de la perfección, conseguimos montar el circuito en el tiempo planeado. En la última etapa, la documentación, el proyecto ha ido a contrarreloj. La razón principal es la mala previsión de tiempo de desarrolló; se pensó iba a ser menor al principio.Por ello, se puede observar en este documento una falta de profundización en todos los temas, que se tratan superficialmente o ni siquiera se nombran.

En conclusión, hemos podido tratar a diferentes niveles algunos de los procesos implicados en el funcionamiento de una calculadora programable. Aunque falten partes importantes por hacer, como el diseño de un teclado numérico y la carcasa, en nuestra opinión, la calculadora se podría considerar funcional. Cumpliendo el objetivo marcado de conocer los entresijos de un dispositivo matemático y realizando una prueba de diseño exhaustiva damos por concluido el proyecto. Aún así, a lo largo de él nos ha surgido la duda, ¿qué utilidad puede tener una nueva calculadora hoy en día? Algo que ha rondado nuestras intenciones desde que empezamos el desarrollo pero que por desgracia no hemos podido llegar a madurar. Tal vez, la calculadora puede tener algún fin además de ser un proyecto didáctico. La grandeza del proyecto consiste principalmente en la libertad. Absolutamente todo, desde la primera línea de código hasta el montaje del circuito se ha apoyado de herramientas libres y públicas. Este hecho es muy interesante pues la decisión de publicar el código y los diseños ayudan a dignificar el carácter didáctico de este proyecto. Gracias a las licencias abiertas, todo aquí creado se puede extender y utilizar en cualquier institución de enseñanza sin ningún percance. Puede servir de ejemplo a cualquier otra persona que se encuentre en una situación similar a la nuestra al principio del proyecto. Pero, desde luego, el punto más importante, es que el proyecto se puede considerar la base de un sistema para una calculadora libre y universal. Un sistema así tendría un alto valor en el campo educativo, por fin los alumnos dispondrían de una herramienta digital especifica y preparada para todas las asignaturas. Un sistema que guiase y potenciase las actitudes de los alumnos ante las matemáticas, las ciencias y las tecnologías.Volviendo a poner los pies en la tierra, lo cierto es que el proyecto se queda lejos de este objetivo. El proyecto se ha publicado enteramente en la red y nuestra intención es de seguir con su desarrollo. Tal vez en un futuro llegue a ser el sistema que se propuso anteriormente.Por ello, nos negamos a poner punto final.

Pág. 46

Calculadora Programable Bibliografía del Proyecto

Bibliografía del Proyecto

• Enciclopedia Visual De las Preguntas, Inventos que Cambiaron el Mundo, Santillana, ISBN9788499070100

• Neuroeducación, Francisco Mora Alianza Editorial, ISBN9788420675336

• Artículo Calculadora, Wikipedia, consultado el 27 de agosto de 2018, https://es.wikipedia.org/wiki/Calculadora

• Artículo Reverse Polish Notation, Wolfram MathWorld, consultado en septiembre de 2018,

http://mathworld.wolfram.com/ReversePolishNotation.html

• Página Calculator (inglés), consultada en agosto de 2018,

https://www.calculator.org

• Microchip, 16-Bit Microcontrollers and Digital Signal Controllers with High-Speed PWM, Op Amps and Advanced Analog (inglés), dsPIC33EPXXXGP50X, dsPIC33EPXXXMC20X/50X and PIC24EPXXXGP/MC20X, 530 páginas, recuperado de http://ww1.microchip.com/downloads/en/DeviceDoc/70000657H.pdf

• Samsung, KS0108B LCD Driver IC (inglés), 18 páginas, recuperado de https://www.newhavendisplay.com/appnotes/datasheets/LCDs/KS0108.pdf

Pág. 47

https://www.newhavendisplay.com/appnotes/datasheets/LCDs/KS0108.pdf

http://ww1.microchip.com/downloads/en/DeviceDoc/70000657H.pdf

http://mathworld.wolfram.com/ReversePolishNotation.html

https://es.wikipedia.org/wiki/Calculadora

Calculadora Programable Apéndice A: Código y proyecto en git.

Apéndice A: Código y proyecto en git.

El proyecto se encuentra ubicado en la plataforma github.com bajo el siguiente enlace:

• https://github.com/rattata2me/cuddly-calculator

Los archivos de make están especialmente creados para poder funcionar en un sistema basado en linux. Aún así es posible ejecutarlos sobre un entorno como Cygwin o MinGW en Windows.Para funcionar es necesario tener instaladas en el sistema las librerías del paquete de Debian build-essential o su equivalente para otra plataforma. También es necesaria la presencia de python y python-imaging en el sistema. Por último, es recomendable el uso de git con el fin de tener una mayor capacidad de tratar con las versiones.El programa en ordenador tiene dos ramas gráficas principales:

• SDL2: Utiliza la librería sdl2 para organizar todos los elementos gráficos y poder mostrar una imagen “simulada” de la pantalla.

• Ncurses: Utiliza Ncurses como motor gráfico. La librería Ncurses está pensada para crear gráficos en terminales Linux.

Recomiendo la primera opción.

Instrucciones para compilarPara compilar el proyecto en una distribución basada en Debian, estas son las instrucciones básicas:

git clone https://github.com/rattata2me/cuddly-calculator.git

cd /cuddly-calculator/tools/lcdsimulator/

make all

Y para ejecutarlo:

./build/main

Pág. 48

https://github.com/rattata2me/cuddly-calculator.git

https://github.com/rattata2me/cuddly-calculator

Calculadora Programable Apéndice B: Imágenes del desarrollo.

Apéndice B: Imágenes del desarrollo.

Pág. 49

Imagen 9: Primera carga de un programa en el procesador.

Imagen 8: Prototipo soldado en una placa de pruebas.

Imagen 10: Prueba de concepto en arduino.

calculadora programable - ies las musas...calculadora programable abstract circuito.....44...

Documents