Max Hernandez

Laberinto - Ejemplo de Canvas en HTML5
Mostrando las entradas con la etiqueta Laboratorio de sistemas integrados. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Laboratorio de sistemas integrados. Mostrar todas las entradas

jueves, 24 de mayo de 2012

Moviendo servomotor en Arduino

¿Qué es un servomotor?

Un servomotor es un componente electromecánico en el cual una entrada electrica determina la posición del motor y/o la velocidad de giro del mismo.

El motor del servo tiene algunos circuitos de control y un potenciómetro (una resistencia variable) esta es conectada al eje central del servo motor. Este potenciómetro permite supervisar el ángulo actual del servo motor. Si el eje está en el ángulo correcto, entonces el motor está apagado. Si el circuito chequea que el ángulo no es el correcto, el motor girará en la dirección adecuada hasta llegar al ángulo correcto.

Ejemplo arduino - controlando un servomotor

Diagrama de conexion:


[Imagen obtenida de: http://blog.bricogeek.com/img_cms/1674-conexionServos.jpg]

Código:

   #include   
       
    Servo servo;  // Crea un Objeto servo  
       
    void setup()  
    {  
      servo1.attach(7);  // Selecionamos el pin 7 para transmision serial  
    }  
       
    void loop()  
    {  
      
      posicion = 0;
      servo1.write(150);
      delay(150);
    } 
 
Video:


Referencias:


http://people.ee.duke.edu/~cec/final/node59.html
http://en.wikipedia.org/wiki/Servomechanism
http://principialabs.com/arduino-serial-servo-control/

Multiplexador y Demultiplexador.

Cuando intentaba programar el cubo de leds, me dí cuenta que algunos leds comparten conexiones con otros por eso me dí a la tarea de investigar diferentes formas para enviar información por un canal.

Multiplexación

La multiplexacion es utilizada para combinar varios canales de información en un solo medio, se logra combinando o sincronizando señales por diferentes métodos. El dispositivo que transmite los mensajes es llamado multiplexor.

Tipos de multiplexación

La multiplexación por división de tiempo:
Es un medio de transmitir dos o mas camañes de información en el mismo circuito utilizando una técnica de tiempo compartido, es muy útil para señales binarias puesto que solo requieren una unidad de tiempo.

Multiplexión por división de frecuencia

En este tipo de multiplexion se utiliza para transmitir varios canales, el espectro de frecuencias, donde cada canal ocupa continuamente una pequeña fracción del espectro de frecuencias transmitido.

Multiplexado estadístico o asíncrono
Este es un caso particular de la division por tiempo y consiste en que los tiempos de espera entre una señal y otra dependen del tráfico existente por cada canal en cada momento así que se podría decir que es adaptativo.

Ejemplos de aplicacion del método:
  • Telegrafia
  • Telefonia
  • Procesamiento digital
  • transmisiones digitales
  • Transmisiones analogas


Código ejemplo - Contador hexagesimal con dos displays

Como ejemplo para esta publicación construí un código de un contador hexagesimal con dos display que comparten el mismo canal para encender las lineas que forman los números.

Materiales:

  •     2 display de cátodo
  •     7 resistencias de 220 Ohms
  •     PIC16F628A
  •     7805-CT Regulador Tension 5V
Diagrama de conexiones:

Código:

#include "pic16f628a.h"
#define __16f628a

unsigned int __at 0x2007 __CONFIG = _INTOSC_OSC_CLKOUT &
  _WDT_OFF&                                                                                                                                           
  _LVP_OFF&                                                                                                                                 
  _DATA_CP_OFF&                                                                                                                              
  _PWRTE_ON;


unsigned short int i, j, z; //Declara 3 variables contadores
unsigned short int contador[2] = {0,0};//Un contador para cada display


int main(void){

  TRISB = 0x00;// Define los puertos del registro TRISB como salidas
  TRISA = 0x00;// Hace lo mismo para el registro TRISA
  PORTA = 0b00000000;
  PORTB = 0x00;

  while(1){
    for(i = 0; i < 20; i++){// Aquí es donde se lleva a cabo el multiplexado
      for( z = 0; z < 2; z++){
          if( z == 0){
              PORTA = 0b00000001;//Aquí manda los datos por el primer canal
          }else{
              PORTA = 0b00000010;//Aquí manda los datos por el segundo canal
          }
          if(contador[z] == 0) PORTB =  0b01111110;// Todos estos if mapean un número con los elementos con los elementos que deben encenderen el display.
          if(contador[z] == 1) PORTB =  0b01001000;
          if(contador[z] == 2) PORTB =  0b00111101;
          if(contador[z] == 3) PORTB =  0b01101101;
          if(contador[z] == 4) PORTB =  0b01001011;
          if(contador[z] == 5) PORTB =  0b01100111;
          if(contador[z] == 6) PORTB =  0b01110111;
          if(contador[z] == 7) PORTB =  0b01001100;
          if(contador[z] == 8) PORTB =  0b01111111;
          if(contador[z] == 9) PORTB =  0b01001111;
          if(contador[z] == 10) PORTB = 0b01011111;
          if(contador[z] == 11) PORTB = 0b01110011;
          if(contador[z] == 12) PORTB = 0b00110110;
          if(contador[z] == 13) PORTB = 0b01111001;
          if(contador[z] == 14) PORTB = 0b00110111;
          if(contador[z] == 15) PORTB = 0b00010111;

          for( j = 0; j < 1000; j++);//Este es el tiempo de espera para que tenga tiempo de encenderse el display
      }
    }

      if( contador[0] == 15){// Estas instrucciones sirven como contador
        contador[0] = 0;
        contador[1] = 0;
      }else{
        if(contador[1] == 15){
            contador[0]++;
            contador[1] = 0;
        }else{
            contador[1]++;
        }
      }


  }

  return 0;

}

Video:



Como puede observarse hay cierto parpadeo mientras se muestra el número debido a que se turnan las señales entre canal, pero aun así los números en los display son legibles así que por esas razones fue que elegí esta técnica para mapear el juego de la vida en la matriz de leds para el proyecto PIC.

Referencias:
http://www.slideshare.net/ggordillo/que-es-la-multiplexacin-presentation
http://www.mitecnologico.com/Main/TecnicasDeTransmisionMultiplexacionYConmutacion

miércoles, 23 de mayo de 2012

Microcontroladores

Uno de los temas de la materia este semestre es microcontroladores con lo cual estaremos trabajando con programadores PIC para este tema, para esto decidí que seria muy útil investigar que es y las características de estos.

[Imagen obtenida de:http://www.sxmicro.com/wp-content/uploads/2008/07/sxchips.jpg]
¿Qué es?

Se considera una computadora sencilla puesto que tiene todas las características de la misma, en un circuito integrado, contiene un cerebro o procesador, Una memoria flash y una RAM (comúnmente de pequeña capacidad) e interfaces periféricas de entrada y salida. Los microcontroladores son utilizados en aplicaciones integradas.

Un sistema integrado es una combinación de software y hardware con ciertas capacidades fijas que fue específicamente diseñada para una función en particular.

Ejemplos de sistemas integrados:
  •  Teléfonos celulares
  •  Reproductores mp3
  •  Relojes despertadores
  •  Alarmas
  •  Receptores RFID
  •  Juguetes

¿Qué tipos de microcontroladores existen?


[imagen obtenida de: http://files.spogel.com/enewsline/p-00362--types_of_microcontrollers.jpg]

Los microcontroladores pueden ser clasificados tomando en cuenta las caracteristicas de el ancho de bus interno, de la orientación de su conjunto de instrucciones, la arquitectura de memoria o de su familia de controladores.


Microcontroladores de memoria interna o integrada.
Se considera microcontroladores integrados los que ya tienen todas los componentes de hardware y software necesarios para su correcto funcionamiento(En especial su memoria). Pocos componentes externos son utilizados( o ninguno) para el funcionamiento y control de los procesos que se llevan a cabo por este microcontrolador. Un ejemplo de esto es un microcontrolador PIC que necesita un oscilador externo para funcionar.

Se considera un microcontrolador de memoria externa a un sistema integrado que tiene no tiene todos los componentes necesarios para su correcto funcionamiento y en especial me refiero a componentes de hardware de memoria. Estos tienen una gran cantidad si no es que toda de la memoria, en componentes externos conectada utilizando un circuito llamado circuito pegamento.


Ancho de bus
Los tres anchos de bus mas utilizados en microcontroladores son:
  • Microcontroladores de 8-bits
  • Microcontroladores de 16-bits
  • Microcontroladores de 32-bits
El ancho de bus es la cantidad de bits en la que se maneja cada instrucción, como vimos en ensamblador esta capacidad tiene que ver directamente con la longitud de palabra de una instrucción del procesador y operaciones que pueden ser soportadas por este.


Arquitectura Cisc and Risc
Existen dos tipos de arquitectura de procesador utilizados en los microcontroladores, estos son:
  • Computadoras con un conjunto de instrucciones complejo (CISC):
    En este las instrucciones compuestas son decodificadas internamente y ejecutadas con una serie de microinstrucciones almacenadas en una ROM internamente lo cual puede resultar lento.
  • Computadoras con un conjunto de instrucciones reducido (RISC):
    En este las instrucciones compuestas residen en la memoria externa y son compiladas directamente como instrucciones internas del procesador lo cual se cree que resulta maás eficiente.


Arquitectura de la memoria
Arquitectura de Harvard
En esta se tienen instrucciones separadas y por tanto controles de señal separados para transferir datos.

Arquitectura de Princeton
En esta se tiene un espacio de direcciones de memoria en común utilizado por la memoria del programa y los datos.

Mi primer Hola mundo

Como ejemplo para este tema, voy a mostrar el código que obtuve mientras jugaba con los puertos de mi PIC, el programa que hice presenta una secuencia de leds en un protoboard, que me sirvio para empezar a entender un poco sobre los registros de mi microcontrolador PIC.

Herramientas utilizadas:
  • SDCC para programar en Ansi C el PIC (lo utilice en ambiente Linux)
  • IC-PROG (Lo utilice en ambiente Windows)
Materiales:
  • Protoboard
  • PIC 16F628A
  • 8 leds
  • 8 resistencias
  • Un 7805 regulador de voltaje
Código:

#include "pic16f628a.h"
#define __16f628a

unsigned int __at 0x2007 __CONFIG = _INTOSC_OSC_CLKOUT & _WDT_OFF&
_LVP_OFF& // Configuraciones de fuses
A_CP_OFF&
_PWRTE_ON;


unsigned short int i; // variable contador

int main(void){

  TRISB = 0x00;// Esto declara los pines como salidas
  TRISA = 0x00;// Los pines se dividen en dos registros por eso estos tambien se declaran
  PORTA = PORTB = 0x00;

  PORTB = 1; //Se ponen todos los pines del registro PORTB como salidas positivas
  while(1){
      for( i = 0; i < 50000; i++);
      if( PORTB == 128){ 
         PORTB = 1; //Se asigna un uno binario a los registros
      }else{
          PORTB = PORTB*2;// Se usa el registro para operaciones multiplicandolo por dos
                          // logramos que se prenda 00000001 *2 = 00000010 el siguiente led
      }
  }

  return 0;

}

El código lo que hace es prender cada led de la fila uno por uno utilizando el registro PORTB como una variable, primero lo igualamos a uno y despues vamos multiplicando por dos con lo cual va a obtener en binario numero con un solo bit en uno avanzando de derecha a izquierda o de derecha a izquierda ya en el protoboard.

Vídeo del programa funcionando



Referencias: 
http://en.wikipedia.org/wiki/Microcontroller
http://www.webopedia.com/TERM/E/embedded_system.html
http://my.safaribooksonline.com/book/electrical-engineering/semiconductor-technology/9788131759905/types-selection-and-applications-of-microcontrollers/section_1.2
http://www.societyofrobots.com/microcontroller_tutorial.shtml

martes, 22 de mayo de 2012

Matrices de leds y probando el cubo de leds

Para llevar a cabo del proyecto de PIC, en algún momento tuve que armar y probar el cubo, antes de poder utilizar el algoritmo de el juego de la vida, aquí quiero compartir un poco de la información que adquirí y mi como probé el funcionamiento del cubo.

Matriz de leds


[imagen obtenida de: http://pcbheaven.com/wikipages/images/howkeymatricesworks_1277658667.png]

Una matriz de leds es un grupo de estos componentes conectado en forma de matriz de tal forma que se puede encender solo un led o la cantidad deseada jugando con los cátodos y ánodos de los mismos.
Las matrices de leds son bastante utilizadas, podemos verlas en todos lados algunos ejemplos de esto son:
  • En anuncios panorámicos, en mi caso en las avenidas
  • En relojes
  • En obras de arte.
  • En carteles

¿Como funciona?


En esta imagen de abajo se muestra como son las conexiones de una matriz de leds donde las columnas corresponden las conexiones a tierra y las filas corresponden a las conexiones a corriente. Al producir corriente a una fila, esta corriente es capaz de pasar por toda la fila y al conectar a tierra una columna toda la columna puede conducir la corriente que pase por esta. Así produciendo corriente en una fila y conectando a tierra la columna cerramos el circuito y hacemos que un led en especifico se encienda. Controlando esto con un microcontrolador podemos crear diferentes figuras o números, en realidad esta funciona de forma muy parecida a un display común y corriente.

[imagen obtenida de:http://galaxi0.files.wordpress.com/2009/06/diagrama-de-pines-catados-en-columna.png?w=500]

Cubo de leds


Un cubo de leds es una estructura bastante similar a la matriz, con la diferencia que los cátodos se mapean como una matriz de cero a nueve, por lo cual necesitamos nueve pines y un ánodo para cada nivel. Lo cual quiere decir que podemos controlar el encendido controlando cada columna y su nivel. Para construirla me base en el siguiente blog: http://roberto-mtz.blogspot.mx/2012/04/cubo-leds-3x3x3-arduino-bt.html el cual tiene publicaciones muy interesantes y me parece muy bueno.

Probando el cubo de leds
Una vez armado me dí a la tarea de generar un código para probarlo, el controlador lo que hace es encender fila por fila para revisar que las conexiones y el soldado esten correctos, despues al final enciende todos los leds al mismo tiempo para verificar que tengan el voltaje necesario.

Materiales:

  •     27 Leds
  •     9 resistencias de 220 Ohms
  •     3 resistencias de 330 Ohms
  •     3 transistores 2N2222
  •     PIC16F628A
  •     7805-CT Regulador Tension 5V

Diagrama de conexiones:

Este diagrama de conexiones lo encontre en una pagina donde querian lograr algo parecido, las conexiones son las mismas, solo que en el PIC cambio los pines de salida RB0-RB7 y RA0 son los catodos y RA1 a RA3.

[Imagen obtenida de: http://www.instructables.com/files/deriv/FGC/TB26/GIYWWDPB/FGCTB26GIYWWDPB.MEDIUM.jpg]

Código:
#include "pic16f628a.h"
#define __16f628a


unsigned int __at 0x2007 __CONFIG = _INTOSC_OSC_CLKOUT &// Internal 
  _WDT_OFF&
  _LVP_OFF&
  _DATA_CP_OFF&                                                                                                                              
  _PWRTE_ON;

unsigned short int i;//variable contador

int main(void){

  TRISB = 0x00;//Configura los pines de PORTA como salidas
  TRISA = 0x00;//Configura los pines de PORTA como salidas
  while(1){
 PORTA = 0b00001110;// Todos los niveles siempre estan encendidos

 PORTB = 0b00000001; // Estado inicial
 for( i = 0; i < 50000; i++);

 PORTB = 0b00000010; //Enciende la segunda columna y espera
 for( i = 0; i < 50000; i++);

 PORTB = 0b00000100;
 for( i = 0; i < 50000; i++);

 PORTB = 0b00001000;
 for( i = 0; i < 50000; i++);

 PORTB = 0b00010000;
 for( i = 0; i < 50000; i++);

 PORTB = 0b00100000;
 for( i = 0; i < 50000; i++);

 PORTB = 0b01000000;
 for( i = 0; i < 50000; i++);

 PORTB = 0b10000000;
 for( i = 0; i < 50000; i++);

 PORTB = 0x00;
 PORTA = 0b00001111;
 for( i = 0; i < 50000; i++);

 PORTB = 0b11111111; // Enciende todos los leds
 PORTA = 0b00001111;
 for( i = 0; i < 50000; i++);

  }

  return 0;

}


 
Ahora uno de los problemas a los que me enfrente en este punto es que todos los leds de un nivel comparten conexión, por tanto si trato de implementar algunas secuencias se encienden leds que no deberían, para resolver este problema utilice una técnica de conexión llamada multiplexado de la cual hablare en la próxima publicación.

Referencias:
http://pcbheaven.com/wikipages/How_Key_Matrices_Works/
http://galaxi0.wordpress.com/about/salidas-y-entradas-digitales/matriz-de-leds/
http://pcbheaven.com/wikipages/How_Key_Matrices_Works/

domingo, 20 de mayo de 2012

Llamadas al sistema

Una llamada al sistema es cuando un programa llama a un servicio del Kernel del sistema operativo. Generalmente estos servicios se encuentran disponibles como instrucciones de lenguaje ensamblador pero algunas veces también pueden llamarse (sin tener conocimiento de ello) desde lenguajes de alto nivel.


Kernel o núcleo
Este se considera el principal componente de los sistemas operativos sirve de interfaz entre aplicaciones y el proceso de los datos de bajo nivel hecho por el hardware del equipo. Entre sus funciones están administrar los recursos del sistema como memoria , uso de CPU por las aplicaciones o acceso a interfaces de entrada y salida del equipo.

Ejemplos de esto son:
  • Exit: Para terminar la ejecución de un programa.
  • Fork: Para crear hilos de ejecución.
  • Time: Para ver la hora actual.
  • Open: Para abrir archivos
  • Close: para cerrar archivos
 Como puede observarse estas son funciones muy utilizadas en cualquier lenguaje de programación pero sin darnos cuenta estas son administradas por el núcleo del sistema operativo.

Llamadas al sistema en linux 

Conceptos útiles:

El espacio kernel: En este espacio residen todas las subrutinas que forman parte del kernel tales como módulos o drivers y cualquier otra que tenga que ver con la interfaz kernel.

 El espacio de usuario: En este espacio se encuentran los programas que utiliza el usuario final, tales como shell y cualquiera de los programas que he estado programando de ejemplos en ensamblador.




Existen diferentes implementaciones en el mundo Linux en los procesadores x86 más antiguos se utilizaban interrupciones para migrar de un espacio de usuario a un espacio Kernel ( lo cuál es un objetivo intermedio de las llamadas al sistema).
En Linux en las llamadas al sistema se utiliza el registro "%eax" para identificar la llamada al sistema que se quiere invocar, la cual se especifica en una biblioteca de Ansi C. Para empezar la llamada al sistema se invoca al vector de interrupción de Linux (0x80) que contiene las direcciones de memoria de los controladores de interrupciones. Cuando una llamada al sistema es generada, el sistema operativo salva el estado de ejecución del proceso y empieza la ejecución del controlador de llamadas al sistema en el vector de interrupciones.

Una vez esto el controla de llamadas al sistema provoca la ejecución de la función "system_call", esta función controla todas las llamadas al sistema, y toma como parámetro el valor contenido en el registro %eax para identificar la llamada en especifico. Una vez realizadas una serio de verificaciones se invoca la llamada real al sistema utilizando la funcion "system_call_table" y el indice en "%eax". Una vez que el kernel termina su ejecución invoca ala función "system_call_exit" y se llama a las transiciones de resumen "resume_userspace" nuevamente para regresar al espacio de usuario para regresar a la aplicación del usuario.




Por último en la página que esta abajo encontré la lista de llamadas al sistema implementadas en el Kernel de Linux, que utilicé como guía para mi ejemplo de este tema.


Ejemplo de llamada al sistema en ensamblador x86


Parametros

En la tabla de llamadas al sistema de linux se puede ver que en a partir de la tercera columna se encabezan nombres de registros y en las celdas tipos de variables. Esto es por que estos registros se utilizan como parámetros para las funciones de llamadas al sistema, el primer parámetro va en el registro "%ebx" el segundo va en "%ecx", el tercero en "%edx" y el cuatro en "%esi", el quinto en "%edi" y el sexto y ultimo en "%ebp".


Hilos usando llamadas al sistema
Como ejemplo de una llamada al sistema decidí implementar la llamada al sistema numero dos del kernel de linux con el que cuento, esta de lo que se encarga es de partir nuestro proceso en dos y crear una copia exacta del mismo que corre de manera independiente del proceso del cual fue creado.
 
.LC0:
 .string "A: %d\n"
.LC1:
 .string "B: %d\n"
.LC2:
 .string "%d\n"
  
 
.globl A  ;Esta función solo sirve para imprimir el resultado
A:             ;con el nombre del thread que lo manda.
 pushq %rbp
 movq  %rsp,  %rbp

 movq 16(%rsp), %rsi
 movq $.LC0,   %rdi 
 movl $0,   %eax
 call printf

 leave
 ret

.globl B  ;Esta hace lo mismo con el threadB
B:
 pushq %rbp
 movq  %rsp,  %rbp

 movq 16(%rsp), %rsi
 movq $.LC1,   %rdi 
 movl $0,   %eax
 call printf

 leave
 ret


.globl threads
threads:
 pushq %rbp  ;Recuperamos la base y el top de la función en el stack de memoria 
 movq %rsp,  %rbp  
 subq $8, %rsp

 movq $50, 16(%rsp)
 movq  $2,  %rax  ;Aquí es donde se define el parámetro al kernel de la función del sistema a la cual queremos llamar
 int $0x80 ;Aquí se hace la interrupción y la llamada a system_call
 
 cmpq  $0, %rax ;El parametro de la llamada se devuelve en el registro %eax
 jz .threadA           ;Si el valor es cero significa que se esta en el proceso padre
 
 cmpq  $0, %rax ; En caso contrario se esta en un proceso hijo
 jg .threadB
 
 cmpq  $0, %rax
 jl .threadB

 
.threadA: ; estas funciones solo aumentan y disminuyen el valor en 16(%rsp), despues salen y terminan su ejecución
 addq $1, 16(%rsp) ; aquí se aumenta
 pushq 16(%rsp)
 call A
 popq %rax
 
 cmpq $100, 16(%rsp)
 jge  .fin

 cmpq $2000, 16(%rsp)
 jl .threadA

.threadB:
 subq $1, 16(%rsp) ; aqui se disminuye
 
 pushq 16(%rsp)
 call B
 popq %rax

 cmpq $0, 16(%rsp)
 jle  .fin

 cmpq $0, 16(%rsp)
 jg .threadB

.fin:
 movq $1, %rax
 int $0x80
 

Lo que imprimió en la terminal es lo siguiente:

Como puede observarse cada impresión en la terminal se hace de forma asíncrona entre las dos funciones, ademas de que a pesar de que parece que comparten la misma dirección de memoria como contador, eso no es verdad pues como vemos la misma variable tiene valores diferentes para cada thread, lo cual nos dice que el kernel nos asigna un nuevo stack de memoria exclusivo para el nuevo thread.


jueves, 10 de mayo de 2012

Manejando la pila de memoria en ensamblador


[imagen obtenida de:http://www.techfuels.com/attachments/ram/17492d1267249742-ram-computerram-main_full.jpg ]
 

¿Qué es la memoria principal?
La memoria principal o RAM (Random Access Memory) es una memoria en la que se puede acceder a cualquier parte de ella sin tener que acceder a partes precedentes de está. Está memoria es mas lentamente accesible que los registros pero mas rápida que el disco duro por eso es utilizada para guardar datos que se están utilizando en un determinado momento por un programa pero que no están siendo utilizados por operaciones comunes en los registros.

De forma lógica la memoria principal que normalmente es de entre uno a cuatro giga bytes es dividida en pequeñas celdas de 1 byte y cada celda se le da una dirección de memoria, después cuando un programa en ejecución necesita guardar datos se le asigna un rango de direcciones para trabajar.



[imagen obtenida de: http://www.jegsworks.com/lessons-sp/lesson4/memaddress.gif]

¿Que es la pila de memoria?
Una pila es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo último en entrar, primero en salir que permite almacenar y recuperar datos.
En lenguaje ensamblador esta estructura de datos se utiliza para llevar control de los datos usados por diferentes bloques del programa y abstraer los bloques de ejecución en funciones y las variables(todo esto muy conocido en lenguajes de programación de capas superiores). Para esto retomaremos el tema de los registros, los registros utilizados por la pila de memoria son:

%ESP Stack Pointer

Este registro es un puntero(contiene la dirección de memoria de otra variable) hacia el ultimo elemento usado en la pila. Este se manipula de forma implícita por quien define el código.

%EBP Base Pointer

Este registro es un puntero que se utiliza para referenciar a los parámetros y variables locales de una función.

%EIP instruction pointer

Este guarda la dirección de la siguiente instrucción del CPU a ser ejecutada y se modifica directamente por las instrucciones "call"(mandar a llamar a una función) y "jmp"(saltar a otro bloque del código).

Ahora que sabemos para que sirve cada registro, necesitamos darnos una idea como se organiza la pila en ensamblador, cada que se entra a una función el puntero %EBP es el que marca donde empieza y termina, en cambio el puntero %ESP nos ayuda a saber donde terminan las variables locales de una función.


[imagen obtenida de: http://unixwiz.net/images/stackframe-cdecl.gif]

Es así que modificando el valor de estos registros punteros podemos manejar asignar fragmentos de memoria para diferentes fragmentos o funciones del programa por ejemplo para declarar una variable entera en Ansi C lo que se haría en assembly x86 seria:

 pushl  %ebp  ;Recupera la base de la pila de la función superior
 movl  %esp, %ebp ;Actualiza la el puntero %esp a la base de la pila anterior
 subl $4, %esp ;Despues le resta cuatro bytes a la dirección de memoria de %ebp
 movl $0,  (%esp) ;Ahora asigna el valor 0 al espacio que reservamos



PUSH
Esta es una operación que decrementa una cantidad de posiciones el puntero base(%EBP) y en la dirección resultante guarda los valores recibidos como operando.

POP
Esta operación sirve para recuperar el ultimo valor empujado con la operación push, esto quiere decir que recupera el valor superior al puntero %EBP y luego incrementa una cantidad de posiciones el puntero.


Ejemplo de recursión
Como ejemplo para manejo de pila decidi hacer el mismo que para la publicación anterior solo que esta vez lo construí utilizando un algoritmo recursivo, para mostrar el movimiento de punteros de pila llamando funciones recursivamente. 

.globl numeros
numeros:
 pushq  %rbp
 movq  %rsp, %rbp  
 jmp .LF                   ;Salta al ultimo bloque de la funcion
.L0:
 movq 16(%rsp),%rax    ;recupera el valor que se dio como parametro
 subq $1, %rax         ;y se le resta uno
 pushq %rax             ;Despues se empuja al puntero para mandarlo como parametro
 call  numeros          ;y se manda a llamar a su misma funcion
 popq %rax             ;recupera el valor parametro es igual a lo que hice cuatro
                             ; lineas anteriores pero ahora modificando el punteor base 
    pushq %rax             ;ahora manda el valor a la funcion print que yo mismo defini
 call  print            ;como en el ejemplo de la publicacion de registros
 popq %rax          
 
 movq 16(%rsp),%rax 
 addq $1, %rax
 movq %rax, 16(%rsp) ;suma uno al parametro recibido y termina la funcion

 leave
 ret
.LF:
 cmpl  $0,  16(%rsp) ;compara el ultimo valor mandado como parametro
 jg .L0                  ;si es mayor que cero pasa al bloque .L0 
    leave
 ret
 
.globl main

main:
 pushq %rbp  ;Recupera la base de la función anterior
 movq %rsp,  %rbp
 subq $8, %rsp 

 pushq $10      ;Mueve el valor 10 a la dirección del nuevo %RBP y disminuye el valor del puntero
 call numeros  ;Manda a llamar a la función numeros
 
 leave
 ret



Y esto fue el resultado que me imprimio en terminal:


Referencias:
http://www.masadelante.com/faqs/memoria-ram
http://www.jegsworks.com/lessons-sp/lesson4/lesson4-5.htm
http://es.wikipedia.org/wiki/Pila_%28inform%C3%A1tica%29
http://unixwiz.net/techtips/win32-callconv-asm.html
http://moisesrbb.tripod.com/unidad3.htm

miércoles, 9 de mayo de 2012

Manejando registros en ensamblador x86


[imagen obtenida de:http://www.elclarin.cl/web/images/stories/2012/marzo/hardware.jpg]

¿Qué es un registro?

En el hardware de las computadoras los registros son memorias que están cerca del procesador, los cuales son la memoria mas rápida de acceder por este, por tanto son muy valiosos para operaciones matemáticas y es muy común que operaciones en ensamblador reciban parámetros dentro de estos espacios de memoria.
Una de las desventajas de estos es que son bastante caros y esto hace que los registros dentro de nuestros ordenadores tengan una capacidad de almacenamiento bastante limitada.

En ensamblador podemos trabajar directamente con los valores de los registros, cosa que no pasa en lenguajes de capas superiores, utilizados de la manera correcta estos pueden ser una herramienta muy útil para generar programas potentes.

Principales registros ensamblador
Dentro de la familia de procesadores x86 existen 8 registros generales cada uno con características diferentes y usado para objetivos particulares, cada registro tiene una capacidad de 32 bits, pero en mis ejemplos quizás trabajaré con instrucciones de 64 bits puesto que la maquina a la que tengo acceso  tiene una arquitectura de 64 bits y el compilador "cc" me lo permite.

Los registros generales son los siguientes:
  • AX - Accumulator Register
  • BX - Base Register
  • CX - Counter Register
  • DX - Data Register
  • SI - Source Index
  • DI - Destination Index
  • BP - Base Pointer
  • SP - Stack Pointer

Se puede trabajar solamente con partes del registro por ejemplo AX representa una parte de 8 bits de tamaño de Accumulator Register, pero si quisieramos trabajar con los 32 bits del registro agregamos la letra "E" al inicio del nombre("EAX") y para registros de 64 bits se utilizaría la letra "R"("RAX")


[imagen obtenida de: http://www.cs.virginia.edu/~evans/cs216/guides/x86-registers.png]

Accumulator Register(EAX)

Este registro sirve para realizar operaciones como por ejemplo sumar o restar. En algunas arquitecturas este tipo de operaciones solo podría llevarse a cabo en un registro especifico para esto, pero en la arquitectura x86 se puede usar cualquier registro, pero es mas recomendable usar EAX puesto que este ya esta optimizado para ser utilizado de esta manera.

Counter Register(ECX)
Este registro es bastante obvio es un registro contador, normalmente se utiliza dentro de ciclos para saber cuando detenerse por lo tanto esto lo hace recomendable  para comparaciones.

Data Register(EDX)

Este registro esta íntimamente ligado con el registro "EAX" este se utiliza cuando los datos con los que trabajamos son muy grandes y no caben en "EAX" entonces la parte mas significativa de los bits del dato se guarda en "EAX" y los menos significativos en el registro "EAX"

Source Index(ESI)
Este se utiliza cuando se requiere trasladar datos de un bloque del programa a otro por ejemplo pasar datos de una función a otra.

Destination Index(EDI)

Este se utiliza cuando se requiere trasladar datos de un bloque del programa a otro por ejemplo asegurar datos en un ciclo para no tener que moverlos a la memoria principal. La diferencia con el registro ESI es que este es orientado a la escritura y el otro a la lectura.

Base Pointer(EBP) y Stack Pointer(ESP)
Este registro esta ligado a la pila de memoria de ensamblador, este registro y el registro "ESP" son la base para la utilización de funciones en el lenguaje ensamblador x86. Se usa para llevar control la abstracción a la cual se le llama función, la memoria principal se utiliza para llevar control sobre en que parte del programa se esta(función) y para saber que bloques de memoria serán utilizados por esta función. El registro "EBP" contiene un puntero al primer bloque de la memoria del rango de bloques para la función y "ESP" representa el ultimo bloque de memoria de una función.

Base Register(EBX)

Este registro es de uso general y no tiene ningún proposito en especifico.

Bloques de código ensamblador

Debido a que una computadora tiene normalmente una gran cantidad de procesos ejecutandose al mismo tiempo(por turnos) es necesario dividir nuestros programas en pequeños bloques de instrucciones dentro de las funciones para que los procesos que se ejecutan al mismo tiempo se turnen ejecutando sus bloques. Para dividir estos bloques se utilizan etiquetas con el siguiente formato ".nombre_de_la_etiqueta:" además estos bloques son utilizados para generar iteraciones en el lenguaje ensamblador.

A manera de ejemplo pongo el siguiente código donde se utilizan bloques de código y comparaciones para generar una iteración donde se imprimen los números del 0 al 9 utilizando un contador.

.globl main
main:
.LFB1: 
        pushq   %rbp  
        movq    %rsp, %rbp
        subq    $16, %rsp
        movl    $0, %ecx ; Mueve el valor incial cero ala variable que servira de contador
        jmp     .L3  ; De aqui salta al bloque de codigo .L3
.L4:
        movl    %ecx, %edi ;Mueve el valor de %ecx al registro %edi para mover el valor a la funcion que se va a ejecutar
        call    print  ;Esta funcion yo la defino recibe un numero entero y lo imprime con un formato especifico con la función printf
        addl    $1, %ecx ;Suma uno al valor del registro
.L3:
        cmpl    $9, %ecx ;Ahora compara el valor de %exc si es mayor que 9 (%ecx > 9)
        jle     .L4  ;En caso de que no se cumpla esa condición salta al bloque .L4

 leave
 ret


Al correrlo me genera la siguiente salida:


El programa no imprime los valores correctos en la terminal debido a que los registros son pocos y tienen una capacidad bastante pequeña, entonces de un bloque a otro, otro proceso podría modificar los valores dentro de los registros por tanto cuando se compara la primera vez tal vez haya conservado el valor 0 pero cuando vuelve a compararse pudo haber sido modificado por otro proceso por ejemplo la función printf puedo haberlo utilizado y haber puesto un valor mayor a 9 en el registro.
En estos casos resultaría útil utilizar la memoria principal para conservar los valores, pues dado que esta es mas grande se puede definir una cantidad de memoria a utilizar por el programa y de esta una mas para la función, lo cual hace los datos más fácilmente respetados por otros procesos. Entonces para corregir este código lo que hice fue:

.globl main
main:
        .LFB1:

                pushq   %rbp
                movq    %rsp, %rbp
                subq    $16, %rsp
                movl    $0, -4(%rbp)  ;Mueve el valor 0 a la memoría principal
                jmp     .L3
        .L4:
                movl    -4(%rbp), %edi ;Mueve el valor principal al registro %edi
                call    print
                movl    -4(%rbp), %eax ;Recupera el valor de la memoria
                addl    $1, %eax        ;Suma 1 al valor de %eax
                movl    %eax, -4(%rbp) ;Devuelve el valor a la memoria principal
        .L3:
                movl    -4(%rbp), %ecx ;Recupera el contador de la memoria principal
                cmpl    $9, %ecx       ;Compara si es menor que 9 valor en el registro
                jle     .L4            ;Salta al bloque .L4 si la condición no se cumplio

              leave
         ret


Y el resultado es el siguiente:



Con esto podemos comprobar que a pesar de que los registros son de muy rápido acceso, son muy limitantes en el sentido de que son escasos y tienen que se repartidos entre procesos en el sistema. A pesar de ello los registros son esenciales en las arquitecturas de computadoras y mezclados con otros medios de almacenamiento y los algoritmos correctos esto los hace muy necesarios y útiles.

Referencias
http://www.swansontec.com/sregisters.html
http://www.cs.virginia.edu/~evans/cs216/guides/x86.html

¿Por que debo aprender ensamblador?



El lenguaje ensamblador es el lenguaje de programación mas básico para cualquier procesador como sabemos un sistema de arquitectura de computadoras comunmente se divide en cinco capaz las cuales son: hardware, firmware, ensamblador, kernel, sistema operativo y aplicaciones. La capa de ensamblador comúnmente define un grupo de instrucciones relativamente fácil de entender por el ser humano estándar para un grupo de procesadores. Este lenguaje casi no contiene instrucciones abstractas lógicas lo que hace es trabajar directamente con operaciones del CPU y estas instrucciones de forma mas directa con los componentes de las computadoras. Otra característica del lenguaje ensamblador es que es bastante poderoso pues no tiene las limitaciones que vienen con lenguajes de programación de capaz superiores aunque resulta mas tedioso trabajar con este.


Breve repaso historico

En la década del 40, surgen representaciones para estas instrucciones. Ya no eran unos y ceros, sino que se los representaba con palabras más fáciles de recordar (instrucciones mnemónicas) como MOVE, LDA, ADD, etc.

La relación con el código binario era directa, por cada instrucción MNEMONICA, existe una instrucción en binario y viceversa. Así se construyen los primeros traductores que pasarán la instrucción MNEMONICA a Binario. Estos traductores recibieron el nombre de ensambladores, y se convirtieron en el primer lenguaje de los ordenadores. De todas maneras, la programación era complicada y difícil, porque se acercaba mucho a la forma de operar de las computadoras y no al lenguaje humano (llamados lenguajes de programación de alto nivel).



¿Por que usar ensamblador?
En primer lugar ¿Por que debería yo estar aprendiendo un lenguaje relativamente complicado si hoy en día existen lenguajes que con menor esfuerzo producen operaciones mucho mas complejas?


Para entender esto lo que hice fue empezar a pensar como funcionaba una arquitectura desde las capas mas bajas, a grandes rasgos junta varias operaciones de su cerebro(CPU) para procesar números guardados en sus registros o memorias, para operaciones mas complicadas necesita juntar un mayor número de instrucciones o repetir muchas veces una misma, esto para ahorrar recursos al fabricar una maquina.
Por ejemplo si se necesitara un procesador cuya única operación fuera sumar un número "A" a un número "B" se podría construir el procesador para que sepa hacer eso, otra forma sería si tuvieramos una operación mas sencilla que sume uno a un valor "A" que recibe y este proceso lo repetimos "B" veces obtendremos los mismos resultados, de forma mas lenta pero ahorrariamos puertos de entrada para el procesador y además sería mas fácil de construir.

De la misma forma en capas superiores se juntan un grupo de operaciones que hacen mas fácil implementar las instrucciones para la maquina, pero que no siempre son las mas óptimas.

Ejemplo

Ahora para ejemplificar esto y entender mejor las características de este y por que es tan importante que un desarrollador de software entienda las mismas utilizare el lenguaje ensamblador versión x86, debido a que paso gran tiempo trabajando en linux y Ubuntu ya trae un compilador de ensamblador x86 a código maquina y también para convertirlo a código ensamblador.

Este es un código en Ansi C que parece bastante sencillo, todo lo que hace es guardar dos valores "a" y "b" en la memoria despues los divide e imprime los resultados en la terminal:

#include                                     
                                                                                
int main(int argv, char** argc){                                                
  int a = 5, b = 4;                                                             
                                                                                
  printf("%d",(a/b));                                                           
  return 0;                                                                     
}


Una vez que construí este código utilice el compilador "gcc" el cual ya viene por defecto en ubuntu para generar código ensamblador, lo cual lo hice agregando el parámetro "-S" y la dirección del archivo:

gcc -S ejemplo01.c

Lo cual me genero el archivo ejemplo01.s con el código en ensamblador x86. Para compilarlo en un ejecutable utilice el comando "cc"

cc ejemplo01.s


Que me generó un ejecutable con el nombre a.out. El código generado es el siguiente(quitando algunas lineas de encabezado y cosas innecesarias y agregando comentarios):

.LC0:
 .string "%d"
 .text
.globl main

main:
.LFB0:
 pushq %rbp  ;Busca la cima de la pila para manejar la memoria principal(RAM)
 movq %rsp, %rbp ;Mueve la posicion de la cima de la pila a otro registro

 subq $32, %rsp       ;Reduce la dirección de la posición para asignar los valores a trabajr
 movl %edi, -20(%rbp) ;Recibe valores pararametro y los pone en la memoria principal
 movq %rsi, -32(%rbp) ;
 movl $10, -4(%rbp)   ;Mueve el valor 10 a una posición en la memoria principal
 movl $2, -8(%rbp)    ;hace lo mismo con el siguiente valor 
 movl -4(%rbp), %eax  ;Mueve el valor 10 de la memoria principal a un registro  
 movl %eax, %edx      ;Ahora mueve el valor 10 a un registro diferente
 sarl $31, %edx       ;Mueve algunos bits menos significativos
 idivl -8(%rbp)       ;Divide el valor 10 entre el valor que esta en la memoria principal en este caso 2
 movl %eax, %esi      ;La funcion anterior pone el resultado de la division en el registro %eax luego este 
                      ; Se mueve a el registro %esi para mandarlo como parametro a la funcion printf de C
 movl $.LC0, %edi     ;Otro parametro a la funcion en este caso un puntero hacia el string que imprimira en pantalla
 movl $0, %eax        ;Otro parametro para definir cantidad de parametros
 call printf          ;Manda a llamar a la funcion printf y en este momento se escribe el valor de la division en pantalla
 movl $0, %eax ;
 leave                ;Pierde el control del programa
 ret                  ;Regresa a la funcion donde fue llamado si no es el caso termina la ejecucion del programa


Como podemos observar la cantidad de instrucciones que tenemos que definir es mayor que en Ansi c esto puede ser una ventaja o una desventaja. La desventaja de esto es obvia aumenta la complejidad para generar código útil. La ventaja esta en que nos deja definir caracteristicas que en otros niveles computacionales el los lenguajes nos esconden por ejemplo el manejo directo de la memoria y o la capacidad de utilizar los registros como queramos los cuales son mas faciles y rapidos de acceder por el procesador.

Al pasar el lenguaje de código Ansi C el cual es mas facíl de construir no genera un código completamente ótimo para utilizarse por ejemplo en este caso mueve distintos valores a la memoria principal cuando podría haber movido uno solo y el otro solamente definirlo como parametro en la división ahorrandonos una posición en la memoria principal. Esto nos da la ídea de que los lenguajes de programación no tienen los algoritmos para traducir un lenguaje a otro nivel (Si es que existe uno) desperdiciando recursos que en algúnas ocaciones pueden ser bastante valiosos(otra ventaja de ensamblador).

Tomando en cuenta que en sistemas integrados trabajare con microcontroladores con una capacidad de almacenamiento y procesamiento muy limitada esta es una  de esas ramas en las que nos es muy conveniente conocer las caracteristicas del lenguaje ensamblador.


Referencias:

jueves, 2 de febrero de 2012

Sistemas integrados

[Imagen obtenida de: http://studentprojectideas.in/wp-content/uploads/2011/08/embedded-systems.jpg]

¿Qué es un sistema integrado?

Estos se consideran sistemas de computación diseñados para realizar tareas especificas y cuentan con pocas funciones. Este normalmente incluye un computador programable como un microcontrolador o un microprocesador pero no se considera a este un computador de propósito general.

Características:
- Tiene un funcionamiento especifico.
- Ya que estos se pueden fabricar en grandes cantidades, se busca reducir los costes lo cual provoca que los sistemas embebidos suelan usar un procesador relativamente pequeño y una memoria pequeña.
- Puede ser un sistema independiente o parte de un sistema mayor.
- Usualmente no necesita memoria secundaria.
- comúnmente deben reaccionar a cambios en el ambiente y hacer cálculos en tiempo real.

Hardware

Como ya sabemos el hardware es cada componente físico que conforma nuestros sistemas, a diferencia de la programación común, para crear sistemas integrados es necesario tener muy en cuenta el hardware con el que estamos trabajando.

Microprocesadores
Un microprocesador se refiere a un circuito integrado de varios miles de transistores que tiene la capacidad de realizar una gran cantidad de funciones y tareas.

Existen tres tipos de microprocesadores los cuales son:


  • Microprocesadores de uso general: Es un dispositivo programable adaptable a una gran variedad de aplicaciones, cuenta con memoria para ejecución de programas ya que no se conoce a ciencia cierta cuál programa será ejecutado.
  • Procesadores de propósito específico: También llamado acelerador y periférico. Se diseña para ejecutar exactamente un programa. 
  • Procesadores específicos de aplicación: Es un procesador programable optimizado para una clase particular de aplicaciones.


Microcontrolador:
Un microcontrolador es un tipo de microprocesador de tipo específico de aplicación optimizado para aplicaciones embebidas.

Ejemplos de microcontroladores:

  • PIC
  • AVR de Atmel
  • 68HC05 de Freescale
  • Mics-68 de Intel

[imagen obtenida de:http://upload.wikimedia.org/wikipedia/commons/thumb/1/18/PIC18F8720.jpg/220px-PIC18F8720.jpg]

Sensores
Un sensor es un dispositivo eléctrico y/o mecánico que convierte magnitudes físicas en magnitudes medibles de dicha magnitud.

La señal medida usualmente debe transformarse a una señal discreta para poder interpretarse esto se logra acondicionando la señal utilizando instrumentos especiales para esto y después se convierte a señal discreta utilizando con convertidor analógico/digital(A/D).

Tipos de sensores:


  • Pasivos: Son los que necesitan energía externa para su funcionamiento.
    • Resistivos: Su medición se basa en la variación de una resistencia.
    • Capacitivos: Su medición se basa en la variación de la capacidad de un condensador.
    • Inductivos:  Su medición se basa en la variación de la inductancia de un bobina.
  • Activos: Estos generan su propia energía.
Algunos ejemplos de sensores son:

  • Sensores de temperatura.
  • Sensores de luz.
  • Sensores de sonido.
  • Sensores de contacto.
  • Sensores de presión.

[imagen obtenida de:https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj71_R0SpnL8iwKHNXWDF0Y22fqjpYEtvUnUVb4HkZoYKJHrTvicQZjfsb3uiD5h298qVEs7lNHYJyMWRXqTIAXxpJ6jK7JVvwNWWUR7FruuAERjEir8pcXA78pCV_0WBjfT3eYlxK_tmjo/s1600/sensores.jpg]

Memoria
La memoria es necesaria en los sistemas integrados, ya sea para guardar el programa que va  a ejecutarse como para guardar el valor de datos necesarios para uso posterior.

Los tipos de memoria comunes en sistemas integrados son:

  • RAM(Random Access Memory): Esta es una memoria que nos permite leer y escribir rápidamente datos. El inconveniente es que estas memorias necesitan siempre estar alimentadas por corriente eléctrica y una ves que se deja de suministrar esta se pierden los datos por lo cúal se le considera una memoria  volátil.
  • ROM(Read Only Memory): En este tipo de memoria los datos no son fácilmente modificables pero los datos no son volátiles.

[Imagen obtenida de: http://static.ddmcdn.com/gif/microprocessor-ram.jpg]

Aplicaciones o ejemplos del computo integrado

Algúnas de las aplicaciones de este tipo de sistemas son las siguientes:

  • Teléfonos móviles
  • Cámaras digitales
  • Robots
  • Maquinas expendedoras
  • Servomotor
  • Lavadoras
  • Microondas
  • Juguetes asesinos.
  • Controladores de partes periféricas de las computadoras.
  • Control remoto de televisores.
  • Sistemas biomédicos.

Aunque cada vez es mas común encontrar este tipo de sistema en cualquier aparato eléctrico.

referencias:
http://www.ciens.ucv.ve/escueladecomputacion/documentos/archivo/88
http://es.wikipedia.org/wiki/Sistema_embebido
http://www.dauniv.ac.in/downloads/EmbsysRevEd_PPTs/Chap01Lesson_6Emsys.pdf
http://es.wikipedia.org/wiki/Instrumentaci%C3%B3n_electr%C3%B3nica#Acondicionadores

Laboratorio de sistemas integrados