miércoles, 22 de febrero de 2012

Sensor iOS con Arduino Introducción


Existen muchas plataformas de multicontroladores plataformas disponibles pero una de las más fáciles es el arduino. El arduino Uno es una placa basada en el microprocesador Atmega328. Cuenta con catorce pines de Entrada/Salida (seis de ellos pueden ser utilizados  como salidas analógicas tipo Modulación por ancho de pulsos junto con otras seis como entradas analógicas).







Especificaciones técnicas.








La plataforma Arduino cuenta con todo lo que se necesita para apoyar al microcontrolador. Se conecta directamente a una Mac para la programación usando una conexión USB, y puede ser alimentado de la misma conexiónUSB o con una fuente de alimentación externa si quieres separar la placa de la Mac una vez que ya se haya programado.

Alimentación de la placa.

El Arduino Uno como ya se mencionó puede ser alimentado vía USB o con una fuente de alimentación externa. A diferencia de otras generaciones de Arduino, la fuente de poder es elegido automáticamente en el Arduino Uno. La placa puede utilizarse con una fuente externa de 6 a 20 volts. La opción más fácil es usar una batería de 9V o un adaptador.

Entrada y Salida

Cada uno de los 14 pines del Arduino Uno puede utilizarse para entrada o asida. Estos pines trabajan con 5 V con una corriente máxima de 40 mA. Cada pin tiene una resistencia pull-up de 20-50 kOhms. 

Algunos pines tienen funciones especializadas. Los pines que más nos interesan en este caso son los pines 0 y 1. Estos se utilizan para recibir (RX) y transmitir (TX) datos serie TTL. Estos pines se conectan con los pines correspondientes del ATmega8U2 y a la conexión USB-Serial a la Mac.


Instalar el software
Arduino Software es de código abierto, se ejecuta en Windows, Mac OS X y Linux. Esta escrito en Java y basado en el procesamiento, AVR gcc- y otro software de código abierto. Se puede descargar en http://arduino.cc/en/Main/Software

Como muchas aplicaciones de Mac, el entorno de desarrollo viene en una imagen de disco (archivo .dmg) el cual se abre automáticamente después de que lo descargas. Después de instalarlo lo abres y tendrás algo así.





Conectar con la placa

Para conectar el Arduino con la Mac con un cable USB apropiado, en el caso de un Arduino Uno, necesitas un cable USB-A (Max) a USB-B (Arduino). El LED verde de encendido tiene que prender, si usas Arduino Uno aparecerá un cuadro de diálogo diciendo que una  la interfaz de red ha sido detectada. 

Después de conectar la placa a la Mac, ve al menú Tools (herramientas) y luego Board (placa) y seleccionas de la lista la placa que estás utilizando. 



Ahora en el menú Tools->Serial Ports selecciona el puerto serial de tu placa. En la Mac, el nombre empieza con /dev/tty.usbmodem para el Arduino Uno.



jueves, 16 de febrero de 2012

Cómo crear un cable de red cat6

Material necesario:

Cable cat6

 Conectores y guía

Pinzas


1. Lo primero que tenemos que hacer es cortar, preparar y pelar el cable de manera que salgan todos los cables de colores que están dentro. Es importante que los cables no se corten o se rompan



2. Una vez que podemos ver los cables de colores, tenemos que separarlos. Los cables deben de quedar completamente separados y lisos como en la siguiente imagen:
 
3. Ahora tenemos que introducirlos en la guía. Es importante tomar en cuenta que los cables no pueden ir en cualquier orden en la guía, deben ir en el siguiente órden:

( Blanco/Naranja, Naranja, Blanco/Verde, Azul, Blanco/Azul, Verde, Blanco/Café, Café)

También pueden ir en el siguiente órden:

 (Blanco/Verde, Verde, Blanco/Naranja, Azul, Blanco/Azul, Naranja, Blanco/Café, Café)

Tenemos que tener cuidado de no romper ningún cable y observar que todos salgan de la guía
4. Cortamos los cables para que todos queden del mismo tamaño


5. Insertamos los cables en la cabeza conectora


Es importante observar bien que los cables queden bien acomodados y que todos estén perfectamente conectados a la cabeza conectora.


 
6. Con las pinzas apretamos el conector para que el cable quede dentro. El cable ya no debe salir o estar flojo por ningún motivo.


7. Ya tenemos nuestro cable! Ahora hay que probarlo...



Bibliografía






miércoles, 8 de febrero de 2012

Sistemas Integrados


Sistemas integrados


Un sistema integrado es un sistema de computación que realiza una o varias funciones dedicadas en un sistema de computación en tiempo real. Estos sistemas se utilizan para cubrir necesidades específicas. En un sistema integrado los componentes están incluidos en la placa base (tarjeta de video, audio, módem, etc.) y en algunas ocasiones los dispositivos resultantes no tienen parecido a lo que tienen las computadoras. Algunos ejemplos de estos sistemas son dispositivos como un taximetro, una tarjeta de control de acceso, el sistema de control de una fotocopiadora, entre otras cosas.

Los sistemas integrados peuden ser programados en lenguaje ensamblador del microcontrolador o microprocesador, así como también pueden programarse en lenguajes como C o C++ utilizando los compiladores específicos. 

Componentes de un sistema integrado


Microprocesador, microcontrolador, DSP son algunos de los componentes que se encuentran en la parte central del sistema. la CPU aporta capacidad de cómputo al sistema, haciendo posible añadir memoria interna o externa. 


La comunicación en los componentes es muy importante, el sistema puede comunicarse mediante interfaces estándar de cable o inalámbricas. Los sistemas integrados normalmente tienen puertos de comunicaciones tipo RS-232, RS-485, SPI, CAN, USB, IP, Wi-Fi, GSM, GPRS, entre otros.

Los elementos electrónicos que el sistema controla son llamados actuadores. Pueden ser motores eléctricos, conmutadores, entre otros.


El módulo de entrada y salida analógicas y digitales se utilizan para digitalizar señales analógicas que proceden de sensores, activar diodos LED, reconocer un estado abierto o cerrado de un conmutador, etc.

El módulo de reloj genera señales de reloj a través de un oscilador principal único. El tipo de oscilador tiene importancia por la frecuencia, la estabilidad y por el consumo de corriente que se requieren. 

El módulo de energía se utiliza para generar las diferentes tensiones y corrientes que se necesitan para alimentar los circuitos del sistema integrado.  


Aplicaciones de sistemas integrados


Algunas de las aplicaciones donde se pueden encontrar los sistemas integrados son los siguientes:
  • En una fábrica, para controlar un proceso de montaje o producción. Habiendo una máquina que se encargue de cierta función específica cuenta con varios circuitos electrónicos para controlar los motores, hornos, etc. los cuales deben ser controlados por un procesador, el cual cuenta con una interfaz persona-computadora para ser controlado por un operador e informarle al mismo como va avanzando el proceso.
  • Puntos de servicio o venta. Las cajas donde pagas en un supermercado cuentan con teclados numéricos, lector de códigos de barra mediante láser, lectores de tarjetas de débito o crédito (banda magnética o chip), pantalla alfanumérica, entre otras cosas. El sistema integrado requiere de muchos conectores de entrada y salida.
  • Puntos de información al ciudadano. En estos establecimientos cuentan con equipos con pantalla táctil donde se puede presionar sobre si misma y elegir la consulta que quieren realizar, obteniendo una respuesta personalizada.
  • Decodificadores y set-top boxes para la recepción de televisión.
  • Sistemas de radar de aviones.
  • Cajeros automáticos.
  • Máquinas de revelado de fotos.


El lenguaje C es más comunmente usado para programar sistemas integrados. El código que genera un compilador C combinado con la capacidad de acceso a capas del software cercanas al hardware son el porque es tan popular en estas aplicaciones.

Una característica donde C muestra su uso en sistemas integrados es la manipulación de bits. Los sistemas integrados tienen registros mapeados en memoria (MMR) mediante los cuales los periféricos se configuran. Estos registros se unen con algunas configuraciones en la misma dirección de memoria, en bits diferentes. 

Ejemplo:

int *mmr; /* puntero al registro que queremos modificar */
mmr = 0x40008ABC; /* dirección de memoria del registro */
 
* mmr |= 1<<7; /* pone a 1 el bit 8 sin modificar los demás */
* mmr &= ~(1<<12) /* pone a 0 el bit 13 sin modificar los demás */

Este tipo de manejo es muy tedioso o imposible en otros lenguajes de alto nivel, ya que se usan operaciones comunes del lenguaje ensamblador que están disponibles en lenguaje C.

jueves, 2 de febrero de 2012

Tarea 1: Lenguaje Ensamblador

El lenguaje ensamblador es un lenguaje que provee a la computadora o a algún otro dispositivo una secuencia de instrucciones dado por una secuencia de códigos binarios.Los programas que se hacen en ensamblador tienden a tener una mayor velocidad y a consumir menos recursos que el programa compilado desde otro lenguaje. El tiempo que tarda en ejecutarse una rutina disminuye,  y el espacio que ocupa es menor.
Por otro lado, un programa escrito en lenguaje ensamblador es mucho más complejo y dificil de crear y leer. A continuación se mostrará un simple hola mundo creado en lenguaje C y después ese mismo programa será traducido en lenguaje ensamblador para hacer una comparación y entender un poco mejor las instrucciones que se muestran en el lenguaje ensamblador. Este programa simple nos servirá para ver las funciones básicas que se requieren en un programa escrito en ensamblador.

Este es un Hola mundo escrito en C:
#include 
int main()
{
printf("Hola mundo");
}
Para que este programa se pueda traducir a ensamblador se necesita seguir los siguientes pasos: 

1. Se compila el programa:
gcc hola.c
2. Se corre el programa:
./a.out
3. Se crea un ejecutable en ensablador. Esto se hará con -S después de gcc:
gcc -S hola.c
4. Ahora estará un archivo con el mismo nombre pero con terminación .s :
hola.s

Este programa se puede abrir en cualquir editor de texto (emacs) y se va a mostrar en lenguaje ensamblador.
Este es el código que se mostró:
   
.file    "hola.c"        #especifica el nombre del archivo original
.section    .rodata      #contiene información de solo lectura del programa inicializado.
.LC0:
.string    "Hola mundo"  #se especifica el texto que se va a imprimir. 
.text                    #agrega el código a la sección de texto del programa
.globl main              #indica que main es global.
.type    main, @function  
main:                    #aqui empieza a correr el main
pushl    %ebp //push local a ebp
movl    %esp, %ebp       #move local a esp y ebp
andl    $-16, %esp       #alinea la pila
subl    $16, %esp        #resta 16 bytes
movl    $.LC0, %eax      #move la cadena a la parte superior de la pila
movl    %eax, (%esp)     #move local a eax y esp
call    printf           #aqui llama a la función printf.
leave
ret                      #return
.size    main, .-main
.ident    "GCC: (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2"
.section    .note.GNU-stack,"",@progbits

Aqui podemos observar que el programa es mucho más largo y contiene más instrucciones que el programa escrito en lenguaje C.  
Después pude reducir la cantidad de líneas de código del programa y así quedo:
.file   "hola.c"     
.LC0:
.string "Hola mundo"
.text
.globl main
main:
pushl   %ebp
movl    %esp, %ebp                              
movl    $.LC0, %eax
movl    %eax, (%esp)
call    printf
leave

El programa todavía corre y ejecuta las mismas acciones que el programa original, y las líneas de código se reducieron un 40%.
Para poder ejecutar este programa y saber que funciona tenemos que seguir los siguientes pasos:
1. Crear el archivo ejecutable a partir del archivo .s:
gcc -o hola.exe hola.s 
2. Se ejecuta el archivo .exe:
./hola.exe

Ahora el programa se va a ejecutar en la terminal. Con esto podemos modificar el código en ensamblador y verificar si todavía funciona.

Ahora hice un programa que genera palindromos de diferentes frases que escriba el usuario. 
Este es el programa en C:

#include 
void inverso (const char * const ptrS ); //prototipo                           
int main()
{
  char enunciado [ 80 ]; //crea un arreglo de caracteres                         
  printf("Escribe una frase: \n");
  gets( enunciado );
  printf("La frase al revez es: \n");
  inverso(enunciado );
  printf("\n");
  return 0;
}
void inverso (const char * const ptrS)
{
  //si es el final de la cadena                                                
  if (ptrS[ 0 ] == '\0' ){
    return;
  }
  else {
    inverso( &ptrS[ 1 ] );
    putchar( ptrS[ 0 ] );
  }
}

Este es el programa generado en ensamblador:
.LC0:
.string    "Escribe una frase: "  #se especifica el texto que se va a imprimir.
.LC1:
.string    "La frase al revez es: " #otro string
.text        #agrega el codigo a la seccion de texto del programa
.globl    main    #indica que la funcion main es global
.type    main, @function
main:  #aqui empieza a correr el main
.LFB0:
.cfi_startproc
pushl    %ebp         #se respalda el %ebp anterior
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl    %esp, %ebp    #move local a esp
.cfi_def_cfa_register 5
andl    $-16, %esp
subl    $112, %esp
movl    %gs:20, %eax
movl    %eax, 108(%esp)
xorl    %eax, %eax
movl    $.LC0, (%esp)
call    puts        #llama a puts
leal    28(%esp), %eax
movl    %eax, (%esp)
call    gets         #llama a gets
movl    $.LC1, (%esp)
call    puts
leal    28(%esp), %eax
movl    %eax, (%esp)
call    inverso
movl    $10, (%esp)
call    putchar
movl    $0, %eax
movl    108(%esp), %edx
xorl    %gs:20, %edx
je    .L2
call    __stack_chk_fail
.L2:
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE0:
.size    main, .-main
.globl    inverso
.type    inverso, @function
inverso:
.LFB1:
.cfi_startproc
pushl    %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl    %esp, %ebp
.cfi_def_cfa_register 5
subl    $24, %esp
movl    8(%ebp), %eax
movzbl    (%eax), %eax
testb    %al, %al
je    .L6
.L4:
movl    8(%ebp), %eax
addl    $1, %eax
movl    %eax, (%esp)
call    inverso
movl    8(%ebp), %eax
movzbl    (%eax), %eax
movsbl    %al, %eax
movl    %eax, (%esp)
call    putchar
jmp    .L3
.L6:
nop
.L3:
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
.LFE1:
.size    inverso, .-inverso
.ident"GCC: (Ubuntu/Linaro 4.6.1-9ubuntu3) 4.6.1"
.section.note.GNU-stack,"",@progbits

Después pude reducir la cantidad de líneas de código del programa y así quedo:
.globl    main    #indica que la funcion main es global
.LC0:
.string    "Escribe una frase: "  #se especifica el texto que se va a imprimir.
.LC1:
.string    "La frase al revez es: " #string
.text        #inicia la seccion de codigo
.globl    main    #indica que la funcion main es global
main:     #indica que empieza el main
.LFB0:
.cfi_startproc
pushl    %ebp         #se respalda el %ebp anterior
movl    %esp, %ebp    #move local a esp
movl    %gs:20, %eax  
movl    %eax, 108(%esp)
movl    $.LC0, (%esp)
call    puts        #llama a puts
leal    28(%esp), %eax
movl    %eax, (%esp)
call    gets         #llama a gets
movl    $.LC1, (%esp)
call    puts        #llama a puts
leal    28(%esp), %eax
movl    %eax, (%esp)
call    inverso     #llama a inverso
movl    $10, (%esp)
call    putchar        #llama a putchar
movl    108(%esp), %edx
xorl    %gs:20, %edx
je    .L2
.L2:
leave
ret
.cfi_endproc
.type    inverso, @function
inverso:
.LFB1:
.cfi_startproc
pushl    %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl    %esp, %ebp
subl    $24, %esp
movzbl    (%eax), %eax
testb    %al, %al
je    .L6
.L4:
movl    8(%ebp), %eax
addl    $1, %eax
movl    %eax, (%esp)
call    inverso
movl    8(%ebp), %eax
movzbl    (%eax), %eax
movl    %eax, (%esp)
call    putchar
jmp    .L3
.L6:
nop
.L3:
leave
.cfi_endproc
.LFE1:

Bibliografía