jueves, 16 de febrero de 2012

Ejercicios para practicar con Arduino

Ejercicios de Arduino:

En esta entrada es mas que nada para ir practicando con arduino. para esto vamos a tomar unos ejercicios del siguiente pdf: http://dl.dropbox.com/u/1894196/ejercicios_de_arduino_resueltos.pdf

Ejercicio 1: “Led parpadeante.”

Descripcion: Se trata de conectar un led al pin13, haciendo que luzca durante 500 ms y que se apague durante 100 ms, este proceso se repetirá cíclicamente.


Codigo:
void setup()
{ //comienza la configuracion
pinMode(13, OUTPUT); //configura el pin 13 como de salida
} //termina la configuracion
void loop()
{ //comienza el bucle principal del programa
digitalWrite(13, HIGH); //envia 5V al pin (salida) 13
delay (500); //espera 500 ms pin 13 con 5V
digitalWrite(13, LOW); //envia 0V al pin (salida) 13
delay (100); //espera 100 ms pin 13 con 0V
}

Virtual BreadBoard:


Ejercicio 2: “Cruce de Semaforos”

Descripcion: Se trata de un cruce de semáforos controlado por arduino, para ello utilizaremos en el primer semáforo los pines 3 (led rojo), 4 (led ambar), 5 (led verde), en el segundo semáforo utilizaremos los pines 6 (led rojo), 7 (led ambar) y 8 (led verde). La secuencia de funcionamiento debe ser : rojo 1 – verde 2 durante 3 segundos, rojo 1 – ambar 2 durante 500 ms, verde 1 – rojo 2 durante 3 segundos, ambar 1 - , rojo 2 durante 500 ms.

Codigo:


int leds[]={3,4,5,6,7,8);
int tiempo1=3000;
int tiempo2=500;
int n;
void setup() {
for (n=0;n<6;n++) {
pinMode (leds[n],OUTPUT);
}
}
void loop () {
digitalWrite (leds[0],HIGH);
digitalWrite (leds[5],HIGH);
delay (tiempo1);
digitalWrite (leds[5],LOW);
digitalWrite (leds[4],HIGH);
delay (tiempo2);
difitalWrite[leds[0],LOW);
digitalWrite (leds[2],HIGH);
digitalWrite (leds[4],LOW);
digitalWrite (leds[3],HIGH);
delay (tiempo1);
digitalWrite (leds[2],LOW);
digitalWrite(leds[1],HIGH);
delay (tiempo2);

digitalWrite(led[1], LOW);
digitalWrite(led[3], LOW);

}

Virtual BreadBoard:


Ejercicio 3: "Secuencia de leds con pulsador"

Descripcion: Se trata de encender y apagar 4 leds secuencialmente al accionar un pulsador. El pulsador debe estarconectado al pin 4, y los leds a los pines 5,6,7 y 8. Se deben encender y posteriormente apagar los leds desde el pin 5 al 8, con un tiempo de duración de encendido y apagado de 200 milisegundos.

 Nota: la secuencia principal del programa debe estar reproducida en una función a la que llamará el
programa principal.

Codigo:

int cadenaleds[]={5,6,7,8};
int pulsador=4;
int tiempo=200;
int n=0;
void setup() {
for(n=0;n<4;n++) {
pinMode (cadenaleds[n],OUTPUT);
}
pinMode (pulsador,INPUT);
}
void flash() {
for (n=0;n<4;n++) {
digitalWrite (cadenaleds[n],HIGH);
delay (tiempo);
digitalWrite (cadenaleds[n],LOW);
delay (tiempo);
}
}
void loop() {
if (digitalRead(pulsador)==HIGH) {
flash ();
}
}

Virtual BreadBoard:






Aqui podran encontrar mas ejemplos:
http://arduino.cc/en/Tutorial/HomePage

Y aqui podran encontrar mas informacion acerca de arduino:
http://www.arduino.cc/en/Reference/HomePage

Documental de Arduino:
http://es.makezine.com/archive/2011/01/arduino_el_documental.html

lunes, 13 de febrero de 2012

Virtual BreadBoard


Virtual BreadBoard



En esta entrada realizaremos unos ejercicios muy basicos de arduino sobre el simulador de arduino:
"Virtual BreadBoard"




Estructura de un Sketch(programa)

Un programa Simple en arduino se compone de almenos 2 partes(Funciones):

  • La primera funcion :Void setup() que es donde establecemos las configuraciones debe ser incluida esta funcion aunque no haya declaracion que ejecutar/li>
  • La segunda Funcion:Void loop() es la que contiene el programa que se estara ejecutando ciclicamente



una vez que el programa se invoca a la funcion setup() despues se llama a la funcion loop() que como su nombre lo indica se ejecuta ciclicamente

void setup()
{
 estamentos;
}
void loop()
{
 estamentos;
}

sin embargo nosotros tambien podemos crear nuestrar propias funciones , de manera que podamos reducir el tamaño de un programa

type nombreFuncion(parametros)
{
 estamentos;
}

Declaracion de variables

  • Variables Globales: Variable que puede ser vista y utilizada por cualquier funcion
  • Variables Locales: variable que puede ser vista o utilizada dentro de la funcion o bucle que se declaro
  • Nota:

    entonces podemos tener 2 o mas variables con el mismo nombre en diferentes partes del programa

Ejemplo :
int valor;   // valor es visible para cualquier funcion
void setup ()
{
              
}
void loop()
{
   for (int i=0; i <20;) //i solo es visible dentro del bucle for        
   {
    i++
   } 
   int j;   // es visible solo dentro de la funcion loop
}
Tipos de Variables:
  • Byte(tiene un rango de 0 a 255 ya que almacena un valor numerico de 8 bits sin decimales):
    byte variable = 200; //Declaramos una variable como tipo Byte
  • Int(Almacena valores numericos de 16 bits, sin decimales, entonces abarca un rango de 32767 a -32768):
    int x=2000; //declara una x como una variable de tipo entero
  • Long(Almacena valores numericos de 32 bits , sin decimales y abarca un rango de -2147483648 a 2147483647):
    long y=90000; //Declaramos la variable "y" como tipo long
  • Float(Almacena valores numericos valores numericos con decimales y abarca un rango de 3.4028235E+38 a -3.4028235E+38):
    float z=3.5; //Declaramos la variable "z" como tipo flotante

Asignaciones Compuestas

Operadores Logicos

Constantes

algunos ejemplos de constantes son las siguientes

  • TRUE/FALSE
    Constantes booleanas en done el false indica un 0 y el TRUE se asocia con cero pero tambien puede ser cualquier otro valor distinto de cero(-2, -5 -200 son definidos como TRUE):

    if(x==TRUE)
    {
       instrucciones 
    }
    
  • HIGH/LOW
    Constantes que se utilizan para escritura o lectura digital. HIGH(alto) se toma como en la logica de nivel 1(ON) o 5 voltios
    LOW(bajo) se toma como logica nivel 0(OFF) o 0 voltios:
    digitalWrite(13,HIGH);  //activamos el pin 13 con un nivel alto(1,ON,5v)
  • INPUT/OUTPUT:
    Constantes utilizadas para definir si un pin va a ser una entrada(INPUT) o salida(OUTPUT):
    pinMode(13, OUTPUT);//Establecemos el pin 13 como salida


Entradas y Salidas Digitales


pinMode(pin, mode)

Esta instruccion es utilizada en la funcion setup() ya que establecemos el modo de trabajo de un pin.

pinMode(13,OUTPUT); //configuramos el pin 13 como salida

digitalWrite(pin, valor)

Con esta instruccion podemos enviar un valor de HIGH o LOW al pin definido previamente como OUTPUT

digitalWrite(pin,HIGH); //Establecemos el valor HIGH en el pin

digitalRead(pin)

Lee el valor de un pin(definido como digital), pudiendo leer HIGH o LOW

valor=digitalRead(pin);  //el estado que se lea del pin se le asignara a valor

Control de tiempo


delay(milisegundos)

Con esta instruccion podemos detener la ejecucion del programa la cantidad de milisegundos que le indiquemos

delay(1000); //se detiene la ejecucion del programa durante 1 segundo

millis()

Devuelve el numero de milisegundos transcurrido desde el inicio del programa hasta el momento actual

Nota:
El numero se desbordara si no resetea despues de 9 horas

valor = millis();

Programa 1


Descripcion:Encender y apagar un led


codigo:

void setup()
{
 pinMode(13, OUTPUT);
}
void loop()
{
 digitalWrite(13, HIGH);
 delay(1000);
 digitalWrite(13, LOW);
 delay(1000);
}

Implementacion: solo Conectamos un led al pin 13(el pin 13 tiene una resistencia interna)


Entradas y salidas Analogicas


analogRead(pin)

Con esta instruccion solo lee el valor de un pin definido previamente como entrada analogica

analogRead(pin);

analogWrite(pin)

Con esta instruccion podemos escribir un pseudo-valor analogico por el metodo de modulacion por ancho de pulso (PWM) a uno de los pin`s del arduino marcados como (pin PWM)

Nota:
Algunos arduinos que implementan el chip Atmega168, permiten habilitar como salidas analogicas tipo pwm los pines 3, 5, 6, 9, 10 y 11. Los que implementan el ATmega8 solo tienen habilitadas los piens 9, 10 y 11 como (PWM)

analogWrite(pin);

Matematicas


min(x,y)

Esta instruccion devuelve el numero mas pequeño , acepta cualquier tipo de datos

x=min(50,100); //asigna el valor de 50 a la variable x

max(x,y)

Esta instruccion devuelve el numero mas grande , acepta cualquier tipo de datos

x=max(50,100);  //asigna el valor de 100 a la variable x

Aleatorio


randomSeed(seed)

Esta instruccion te permite colocar una variable, constante o una funcion lo que te permitira generar numeros aleatorios

randomSeed(seed);

random(min,max)

Con esta instruccion nos permitira generar numeros aleatorios estableciendo un rango minimo y otro maximo

x=random(50,100); // asigna a la variable x un valor entre los rangos de 50-100

Puerto Serie


serial.begin(rate)

Esta instruccion abre el puerto serie y fija la velocidad en Baudios

Notas:
  • El valor tipico de velocidad para comunicarse con el ordenador es de 9600

  • Cuando se utiliza la comunicacion serie los pins digital 0(RX) y 1(TX) no puede utilizarse al mismo tiempo
  • setup()
    {
    serial.begin(9600); //abre el puerto serie y establece la velocidad en 9600 bps
    }
    

    serial.println(data)

    Esta instruccion Imprime los datos en el puerto serie, seguido de un retorno de carro automatico y salto de linea.

    serial.println(analogValue); // Envia el valor analogValue al puerto 
    

    serial.print(data,data Type)

    Con esta instruccion podemos detener la ejecucion del programa la cantidad de milisegundos que le indiquemos

    serial.println(data,data Type);
    

    Lenguaje Maquina



    Hola Mundo (Lenguaje Maquina)


    Esto lo haremos utilizando el comando DEBUG , que solo funciona en windows y arquitecturas de(X86)

    Gracias al comando DEBUG podemos introducir codigo hexadecimal para hacer mas facil las cosas, empecemos :

    Paso 1 : abrimos el simbolo del sistema y tecleamos lo siguiente:

    debug



    Paso 2:  Escribimos lo siguiente:

    e 100 b4 09 ba 09 01 21 cd 20 48 6f 6c 61 2c 20 6d 75 6e 64 6f 24

    Donde:
    e= entrada
    100= Localidad de memoria 100
    Lo demas codigo hexadecimal con la palabra Hola Mundo


    Paso 3: Ahora le decimos a la computadora que ejecute el codigo maquina anterior, solo escribimos:
    g
    Donde:
    g= go


    Paso 4: ahora guardamos las instrucciones en un archivo para ejecutarlo posteriormente, debemos indicar el numero de bytes a escribir en el archivo y este valor lo debemos escribir en los registros BX y CX:

    n HolaMundo.com
    rbx
    rcx
    15
    w
    q


    Donde:
    n=name
    rbx= Registro BX
    rcx=Registro CX
    15 = 15  hexadecimal es igual a 21 decimal (21 bytes) le indicamos que queremos guardar 21 bytes
    w= para indicar que queremos escribir el archivo 
    q= salir


    Paso 5: Ver y corrrer el programa creado :

    dir
    holamund



    donde:
    dir= ver directorios
    holamund= ejecutamos nuestro programa

    lunes, 6 de febrero de 2012

    Lenguaje Ensamblador

    Introduccion Lenguaje Ensamblador



    Introduccion al Lenguaje Ensamblador

    El Lenguaje Ensamblador es equivalente al lenguaje Maquina, pero con códigos de operacion, datos y referencias simbólicas

    Entonces el lenguaje ensamblador expresa las intrucciones de una forma mas natural al hombre y a la vez muy cercana al microcontrolador y microprocesador, ya que cada una de estas instrucciones corresponde con otra en codigo maquina

    El Lenguaje Ensamblador trabaja con nemónicos, que son grupos de caracteres alfanumericos que simbolizan las ordenes o tareas a realizar


    * Operaciones:Códigos Nemotécnicos
    * Datos y Referencias: Nombres Simbolicos

    La traduccion de los nemonicos a codigo maquina la lleva a cabo un programa ensamblador

    El programa escrito en lenguaje ensamblador tiene una extension (.asm). El programa ensamblador traduce ese codigo fuente (.asm) a codigo maquina que suele tener la extension (.hex)


    El codigo Fuente (Ensamblador)


    Cada linea puede estructurarse en hasta 4 campos ó columnas separadas por uno o mas espacios o tabulaciones entre si

    campo de etiquetas:
    Expresiones Alfanumericas escogidas por el usuario para identificar una determinada linea. todas las etiquetas tienen asignado el valor de la posicion de memoria en la que se encuentra el codigo al que acompañan

    Campo de codigo:
    Corresponde al nemonico de una instruccion de una directiva o de una llamada a macro

    Campo de operandos y datos:
    Contiene los operandos que precisa el nemonico utilizado según el codigo puede haber 2, 1 o ningun operando.

    Campo de Comentarios:
    Dentro de una linea todo lo que se encuentre a continuacion de un punto y coma (;) sera ignorado por el programa ensamblador y considerado como comentario


    Campo de codigo

    Puede corresponder ese codigo a:

    Instrucciones:
    son aquellos nemonicos que son convertidos por el ensamblador en codigo maquina

    Directivas:
    Pseudoinstrucciones que controlan e proceso de ensamblado del programa. son indicaciones al programa ensamblador de como tiene que generar el codigo maquina

    Macros:
    Secuencia de nemonicos que pueden insertarse en el codigo fuente del ensamblador de una manera abreviada mediante una simple llamada



    Programa (Hola Mundo en Ensamblador)


    Los pasos para crear nuestro programa "hola mundo " en ensamblador son los siguientes:

    Paso 1:
    instalaremos el programa ensamblador en este caso NASM con el siguiente comando :

    • Ubuntu : apt-get install nasm
    • Fedora: yum install nasm

    Paso 2:
    Ahora si copias el Siguiente Codigo fuente y lo guardas con el nombre que quieras pero con extension(.asm):


    section .data
        holaStr:    db 'Hola Mundo!',10
        holaSize:      equ $-holaStr
    
    section .text
        global _start
    
    _start:
        
        mov eax,4            ; llamada del sistema 'write' identificador 4
        mov ebx,1            ; descriptor de archivo 1 = pantalla
        mov ecx,holaStr      ; cadena que mostraremos
        mov edx,holaSize     ; longitud de la cadena 
        int 80h              ; invocar al kernel
    
    
        mov eax,1            ; llamada del sistema 'exit'
        mov ebx,0            ; codigo de error 0
        int 80h              ; invocar al kernel 
    
    

    Paso 3:
    Creamos a partir del codigo fuente (.asm) el codigo objeto, Gracias al programa ensamblador con el comando:

    nasm -f elf (nombre archivo).asm


    Paso 4:
    Creamos a partir del codigo objeto (nombre archivo.o) el ejecutable,con el comando:


    ld -o nombre_ejecutable nombre_codigo_objeto.o


    Paso 5:
    solo queda Ejecutar el programa ,con el comando:


    ./nombre ejecutable