domingo, 20 de mayo de 2012

Arduino + Shield Ethernet

Realiza un programa utilizando arduino + la shield ethernet  y se trata acerca de un servidor, lo que hace es que controla 3 leds desde un servidor, prendes cada uno de ellos y aumentas o bajas su intensidad.

Material Utilizado:

Arduino +Shield Ethernet
3 leds
3 resistencias
1 cable ethernet

Còdigo

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

//mac, IP
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192,168,1,6 };
EthernetServer server(80);//ethernet server port 80
//pines out LED
int Red = 5;
int Green = 4;
int Blue = 3;
//para activar los colores del LED
boolean flatRed = false;
boolean flatGreen = false;
boolean flatBlue = false;
//para controlar la intesidad de luz
int steep=15;//paso de intensidad de color en los LEDs
int depth=120;//intensidad inicial
boolean reading = false;


//HTML creacion de formulario
const char html[] =
"
" "" "" "" " " "" "
"; void setup(){ Serial.begin(9600); //iniciar conexion Ethernet.begin(mac, ip); server.begin(); //activar pines pinMode(Red,OUTPUT); pinMode(Green,OUTPUT); pinMode(Blue,OUTPUT); } void loop() { // Escuchar a los clientes que entran EthernetClient client = server.available(); if (client) { // una peticion http termina con una linea en blanco boolean currentLineIsBlank = true; boolean sentHeader = false; server.print(html);//puesta HTML en servidor while (client.connected()) { if (client.available()) { if(!sentHeader){ sentHeader = true; } char c = client.read(); if(reading && c == ' ') reading = false; if(c == '?') reading = true; //encuentra ? donde inicia la informacion if(reading){ Serial.print(c);//imprime lo que recibe del cliente //control del LED if(c == '3'){ flatRed = false; analogWrite(Red , LOW); //lo desactiva y lo apaga flatGreen = false; analogWrite(Green , LOW); flatBlue = true; //activa el color del LED break; } if(c == '4'){ flatRed = false; analogWrite(Red , LOW); flatGreen = true; flatBlue = false; analogWrite(Blue , LOW); break; } if(c == '5'){ flatRed = true; flatGreen = false; analogWrite(Green , LOW); flatBlue = false; analogWrite(Blue , LOW); break; } //para intensificar botones 1 sube, 2 baja if(c == '1'){ if(depth == 255) depth=255; else depth = depth+steep; break; } if(c == '2'){ if(depth == 0) depth=0; else depth = depth-steep; break; } } if (c == '\n' && currentLineIsBlank) break; if (c == '\n') { currentLineIsBlank = true; }else if (c != '\r') { currentLineIsBlank = false; } } } delay(1); // give the web browser time to receive the data client.stop(); // close the connection: } if (flatRed == true) analogWrite(Red , depth); if (flatGreen == true) analogWrite(Green,depth); if (flatBlue == true) analogWrite(Blue ,depth); }

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

byte mac[]={ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[]={ 192,168,1,6 };

EthernetServer server(80);

int disp [10][8]={{7,8,4,3,2,6},{8,4},{7,8,5,2,3},{7,8,5,4,3},{6,5,8,4},{7,6,5,4,3},{2,3,4,5,6,7},{8,4,7},{2,3,4,5,6,7,8},{4,5,6,7,8}};
int i;
const char html[] = 
"
" "" "" "
"; void setup(){ Serial.begin(9600); Ethernet.begin(mac, ip); server.begin(); pinMode(2,OUTPUT); pinMode(3,OUTPUT); pinMode(4,OUTPUT); pinMode(5,OUTPUT); pinMode(6,OUTPUT); pinMode(7,OUTPUT); pinMode(8,OUTPUT); } void loop(){ EthernetClient client =server.available(); if (client){ Serial.print("hola/n"); server.print(html); while(client.connected()){ if(client.available()){ int j = client.read(); digitalWrite(2,LOW); digitalWrite(3,LOW); digitalWrite(4,LOW); digitalWrite(5,LOW); digitalWrite(6,LOW); digitalWrite(7,LOW); digitalWrite(8,LOW); for (i = 0; i < 8; i = i + 1) { digitalWrite(disp[j][i],HIGH); } delay(1000); } } } }

miércoles, 16 de mayo de 2012

El Compilador C






Este Compilador traduce el código C del archivo fuente (.c) a  lenguaje máquina para los microcontroladores PIC, gel compilador son:



  • Cuando se compila nos genera un código máquina muy compacto y eficiente.
  • Podemos integrarlo con MPLAB  y algunos otros simuladores/emuladores como por ejemplo Proteus para el proceso de depuración.





Compilador PCW CCS










Este Compilador traduce el código C del archivo fuente (.c) a  lenguaje máquina para los microcontroladores PIC, generando así un archivo en formato hexadecimal (.hex), además del hexadecimal también nos genera 6 archivos más con las siguientes extensiones:
  • .tre
  • .sym
  • .sta
  • .pjt
  • .lst
  • .h


Algunas de las características del compilador son:

  • Cuando se compila nos genera un código máquina muy compacto y eficiente.
  • Podemos integrarlo con MPLAB  y algunos otros simuladores/emuladores como por ejemplo Proteus para el proceso de depuración.
  • Incluye una biblioteca muy completa de funciones precompiladas para el acceso al hardware de los dispositivos (entrada/salida, temporizaciones, conversor A/D, transmisión RS-232,bus I2C….,etc.
  • Incorpora drivers para dispositivos externos,  como por ejemplo  pantallas LCD, teclados numéricos, memorias EEPROM, relojes en tiempo real, etc.
  • Nos permite insertar partes de código ensamblador, manteniendo otras partes del programa en c. 


Características del lenguaje C en el compilador PCW

El lenguaje C estándar es independiente de cualquier plataforma, pero para programar PIC debemos de disponer de comandos específicos los cuales estén referidos específicamente a las partes del hardware del microcontrolador como por ejemplo el acceso a la memoria, temporizadores entre muchos mas.

Es por eso que además de los datos dore lenguaje ANSI C, el compilador PCW incluye bibliotecas que incorporan determinados comandos que no son estándar, sino específicos de la familia de microcontroladores PIC.


Éstos son básicamente de dos tipos:

  • Directivas del preprocesador
  • Funciones precompiladas


Directivas del procesador

El compilador PCW dispone de 7 tipos básicos de directivas:

--> Directivas derivadas del estándar de C que nos permiten un control básico del código y del flujo en el proceso de compilación además de otras funciones:

#DEFINE
#ELIF
#ELSE
#ENDIF
#ERROR
#IF
#IFDEF
#IFNDEF
#INCLUDE
#LIST
#NOLIST
#PRAGMA
#UNDEF

--> Directivas asociadas a las bibliotecas precompiladas, que proporcionan al compilador información relacionada con estas bibliotecas:

#USE DELAY

#USE FAST_IO
#USE FIXED_IO
#USE I2C
#USE RS232
#USE STANDARD_IO

--> Directivas que están relacionadas con la especificación del dispositivo por un lado para definir los mapas de memoria y el juego de instrucciones y por otro lado  incluir información necesaria para la programación del dispositivo en los ficheros de salida de la compilación:

#DEVICE
#ID
#FUSES
#TYPE

--> Directivas de cualificación de funciones se utilizan para identificar las características especiales de una función:

#INLINE
#INT_DEFAULT
#INT_GLOBAL
#INT_xxxxx
#SEPARATE 

--> Directivas de control del compilador, para definir opciones referidas a la compilación del código del programa:

#CASE
#OPT
#ORG
#PRIORITY

--> Directivas de control de la memoria del microcontrolador gestiona y reserva el uso de memoria para variables:

#ASM
#BIT
#BYTE
#ENDASM
#LOCATE
#RESERVE
#ROM
#ZERO_RAM

--> Identificadores predefinidos.

Todas las directivas que mencionamos son interpretados por el compilador, no por el microcontrolador. También se incluyen dentro del término genérico de directivas unas variables que contienen información sobre el proceso de compilación denominadas como identificadores predefinidos del compilador:

__DATE__
__DEVICE__
__PCB__
__PCH__
__PCM__


Funciones precompiladas


Funciones en C incluidas en el compilador PCW para manejar los diferentes recursos del microcontrolador, desde el bus I2C hasta el conversor A/D.



Utilidades adicionales

El entorno PCW también incluye:

Estas se encuentran en los menús View y Tools de la barra de menús.


  • Monitor del puerto serie: terminal que monitoriza la entrada y la salida del puerto serie del computador.
  • Selección de dispositivos: Tiene una base de datos  con los dispositivos que puede programar el compilador en donde se incluye sus características hardware.
  • Editor de dispositivos: Al igual que selección de dispositivos también emplea la base de datos  y permite editar los componentes para modificar sus características hardware, así como añadir nuevos dispositivos o eliminar algunos de ellos.
  • Conversor numérico: realiza conversiones entre los tipos de datos unsigned, signed, hex y float.
  • Extracción de datos de calibrado: Nos permite leer los datos de calibración existentes en la memoria de programa de un determinado dispositivo.
  • Desensamblador: Lee un fichero en Código máquina y lo traduce a su equivalente en Ensamblador, con lo que se podría insertar este código en un programa en C, mediante las directivas #ASM y #ENDASM.






Manual: PCW  CCS

Bibliografía:

Referencia1
Referencia2

Imagenes
Referencia1
Referencia2

martes, 15 de mayo de 2012

Nuestro primer circuito en Proteus

Comenzaremos con un pequeño circuito en donde los componentes que utilizaremos serán:
  • Un interruptor (switch)
  • Un foco 12V (lamp)
  • Una batería 12V  (battery)





Primero que nada abrimos Proteus ISIS, ya abierto. 

Para seleccionar los componentes que se utilizaran en el proceso seleccionamos el siguiente icono:


Este icono es la herramieta de los componentes.









Seleccionamos el botón P y se nos abrirá la ventana de componentes en donde seleccionaremos los tres que mencionamos arriba. Para hacerlo más facil lo que se hara es buscar el componente  en la zona de búsqueda automática del componente:



Primer componente (SWITCH)



Cuando terminemos de teclear presionamos enter y por default nos aparecera en la vista previa del componente un switch y después daremos aceptar (OK) sin seleccionar nada:



<--Vista previa del componentes.




Ya dandole al OK seleccionaremos en la zona de trabajo en donde queremos ponerlo y le damos clic, recuerden que el puntero cambia a forma de un lapiz.


Para los 2 elementos que faltan haremos los mismos pasos teclearemos el componente y sin seleccionar nada solo le daremos OK.


Segundo componente (LAMP)








<--Vista previa del componentes.






Tercer componente (BATTERY)






<--Vista previa del componentes.






Ya teniendo los componentes comenzaremos a acomodarlos en el zona de trabajo para que queden de la siguiente manera:




Ya teniendo los componentes acomodados de esta manera, activaremos la tecla Enable/Disable para unir los dispositivos:







Lo único que aremos es seleccionar un extremo de un dispositivo y darle clic y después seleccionamos el extremo del siguiente dispositivo y así sucesivamente hasta completar el circuito.





Ya tenemos nuestro primer circuito, ahora pasaremos a la simulación de este os vamos a la zona de simulación:




Y seleccionamos la opción Play:







Al seleccionar la opción Play el circuito:


Aquí les dejo este vídeo donde muestro la simulación del circuito como ven el foco que pusimos se ve que prende =)


Dejo el programa en ISIS: Link de descarga



Tercer programa en Arduino: Numeros de 0 al 9 con un display
















Los materiales que se utilizaran serán:
  • Arduino UNO











  • display (catodo común)















  • Cable USB













  • Cable para conexión














Aquí les muestro el código:

int disp [10][8]={{7,8,4,3,2,6},{8,4},{7,8,5,2,3},{7,8,5,4,3},{6,5,8,4},{7,6,5,4,3},{2,3,4,5,6,7},{8,4,7},{2,3,4,5,6,7,8},{4,5,6,7,8}};

int i;
int j=0;

void setup(){
pinMode(2,OUTPUT); 
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
}

void loop(){
  digitalWrite(2,LOW);
  digitalWrite(3,LOW);
  digitalWrite(4,LOW);
  digitalWrite(5,LOW);
  digitalWrite(6,LOW);
  digitalWrite(7,LOW);
  digitalWrite(8,LOW);
  for (i = 0; i < 8; i = i + 1) {
  digitalWrite(disp[j][i],HIGH);
  }
    delay(1000);
  j=j+1;
  if(j==10){
   j=0; 
  }
  
}
Ahora para compilarlo y cargarlo al arduino nos vamos a la pantalla de arduino 1.0 y seleccionamos los iconos siguientes:
Imagen


Video


Bibliografía:
 Referencia1
 Referencia2
 Referencia3
Referencia4



Segundo programa en Arduino

Este es mi y que primer programa en arduino y se trata de prender un led y que este se apague con este usando de forma de conexión una salida digital:




Los materiales que se utilizaran serán:
  • Arduino UNO











  • led (color: violeta)













  • Cable USB















Ahora para empezar tenemos que aclarar que el pin que se utilizara será el 13, se preguntaran por que no utilizamos resistencia, esta no se utiliza ya que como utilizaremos el pin 13 de Arduino ya incluye en la tarjeta esta resistencia.

Aquí les muestro el código:

int led=13;

void setup()//parte encargada de recoger la configuracion.
{
  pinMode(led,OUTPUT);//configura el pin 13 como salida.
}

void loop() //contiene el programa que se ejecutara ciclicamente.
{
  digitalWrite(led,HIGH);//pone en uno(on, 5v) el pin 13. (LO ENCIENDE)
  delay(1000);//espera 1000 milisegundos
  digitalWrite(led,LOW);//Apaga el Led
  delay(1000); //espera 1000 milisegundos 
}
Ahora para compilarlo y cargarlo al arduino nos vamos a la pantalla de arduino 1.0 y seleccionamos los iconos siguientes:







Imagen:




Video:

Bibliografía:

Referencia1
Referencia2
Referencia3

domingo, 13 de mayo de 2012

Proteus

En esta entrada les hablare un poco de Proteus.

En la actualidad existen muchos programas que nos posibilitan la creación de circuitos además de la PCB, pero muchos de estos no nos permiten simular el circuito, podemos decir que es la vetaja que tiene Proteus  el cual nos permite simular en tiempo real los circuitos que cremos pudiendo visualizar gráficas con los valores que obtengamos, comprobar valores de tensión e intensidad en cualquier parte del circuito y, además, permitirnos interactuar con todos los componentes del circuito susceptibles de ello.



A parte de lo anterior mencionado tambiém permite simular microprocesadores que podamos haber incluido en el circuito y nos da la posibilidad de programarlos y depurar los programas desde la misma aplicación 

Además de esto también encontramos un software de diseño de esquemas (Isis) y de PCBs (Ares).

Introducción a ISIS

ISIS es un programa en donde podemos dibujar circuitos en un area de trabajo los cuales después se pueden simular.

Primero que nada conoceremos de lo que se componen:





Dejo en claro que solo es lo mas importante por q faltan muchas cosas por mencionar.

Ahora explicare cada uno de los componentes de ISIS:

Barra de titulo





Esta se encuentra en la parte superior, nos muestra el icono del programa, el nombre del fichero abierto, la leyenda “ISIS Professional” y, en ocasiones, mensajes de que el programa ha entrado en un modo particular de funcionamiento (por ejemplo, Animating, cuando se simula).

Zona de trabajo



Aquí es donde realizamos nuestro circuito. Esta zona también cuent con un centro geometrico pero este no se imprime.












Para seleccionar los componentes que se utilizaran en el proceso seleccionamos el siguiente icono:


Este icono es la herramieta de los componentes Pulsando en ese botón veremos como a la derecha de la barra de herramientas se activará una lista que se encontrara vacia con el título de devices.




Podemos observar como a la izquierda de este título hay dos botones:










Al pulsar en el botón "P" tendremos acceso a la ventana de selección de componentes:



Ahora vamos a seguir los pasos anterioreS:


Paso 1: Seleccionamos el icono de la herramienta de componentes-
Paso 2: Seleccionamos el botón "P" y se nos despliega la ventana de selección de componentes.
Paso 3:  En la sección de ctegorias ordenadas alfabéticamente seleccionamos la opción de Resistor y en  Subcategoría seleccionamos la que ocupemos, también escogemos el fabricante:




(Estan fueron las elecciones que realize)


Paso4: Ya seleccionando lo anterior nos desplegara los componentes en la zona de resultados y seleccionamos lo que buscamos:






Paso5: Ya seleccionado se muestra la vista previa del componente y el Patillaje del PCB:













Vista previa











Patillaje del PCB
Paso 6: Le damos en el botón OK y nos regresa a la pantalla inicial de ISIS,  y en l ventana de vista completa observamos el componente que elegimos:



Paso 7: Después podemos seleccionar el area donde queremos ponerel componente que elegimos, al pasar el mouse sobre la zona de trabajo el puntero cambiara a icono de un lapiz :

Y si damos clic sobre esta zona el componente se pondra en esta zona:



Y asi podemos seguir po niendo mas resistencias, también podemos cambiar su posición dandole clic derecho y se nos depsliega el menu donde nos brinda esta opción:



También les dejo un link donde pueden descargar un tutorial de Proteus para familizarizarse mas con el manejo de este: Link


Bibliografia:

miércoles, 9 de mayo de 2012

Como programar un PIC en 3 pasos 

Como vimos en la entrada anterior  un PICmicro es un circuito integrado programable. 

Para poder programar un PIC podemos basarnos en tres pasos los cuales son los siguientes:


  • Desarrollo de Software
  • Programación del microcontrolador  (PIC)
  • Prueba y verificación
Ya puesto los pasos ahora daremos una explicación de lo que se hace en cada uno.



Desarrollo de Software

En este editar se refiere a escribir el programa o mejor dicho realizar una lista de instrucciones en un lenguaje que le indicara al PIC lo que nosotros queremos que haga. 

Podemos usar diferentes lenguajes para programarlo como por ejemplo Basic, ensamblador, C y entre muchos otros. 


Compilar:


Como sabemos el PIC no entiende lenguaje como Basic y entre los que ya se han mencionado, este solo conoce ceros y unos.
Se refiere a traducir el programa que hicimos a lenguaje maquina que este es el lenguaje que entiende el PIC. Para poder hacer esto es necesario un software para transformar el código con el cual podamos comunicarnos con el PIC. 


En el desarrollo de software existen diferentes maneras de desarrollar el programa que depende del lenguaje inicial que se utiliza para escribir el programa:


  • Languaje Assembly- Lenguaje maquina/Còdigo objeto
            (.asm) -->ensamblador  --> (.hex, .o, .bin, .coff)


  • Lenguaje de Alto Nivel - Lenguaje Assembly - Lenguaje de Máquina/Código Objeto
         (.c, .cpp) --> Compilador -->(.asm) --> ensamblador --> (.hex, .o, .bin, .coff)


En la siguiente figura mostraremos las dos alternativas que mencionamos arriba el cual tiene el desarrollador para generar el código máquina que es entendido por el microcontrolador:








El método básico es escribir el programa en lenguaje ensamblador en un archivo de texto con extensión .asm y después utilizar una programa ensamblador para generar un archivo en lenguaje de máquina, también denominado código de máquina o código objeto (object code), compuesto por instrucciones en código binario que son directamente entendidas por la CPU del microcontrolador. 



El ensamblador normalmente genera un archivo con extensión .hex (hexadecimal), .o (objeto), .bin ( binario), o .coff (common object file format) dependiendo del ensamblador.   La ventaja es que el código de máquina generado a partir de un programa escrito en lenguaje de máquina es por lo general más eficiente, ya que el programa se desarrolla en un nivel cercano a las características del hardware.


La otra alternativa es usar un lenguaje de alto nivel, lo cual son más fáciles de usar y reducen los tiempos de desarrollo.  Entre los más comunes encontramos es el C , C++, BASIC entre otros. Ya teniendo el programa escrito necesitaremos un compilador para traducirlo a lenguaje ensamblador o directamente a lenguaje máquina. 



Programación del microcontrolador (PIC)


Este es el paso en el cual programamos el PIC mediante una tarjeta electrónica y un poco software se pasa el programa.



Este proceso corresponde a utilizar un programa en el PC que toma el código ensamblado (.hex, .o, .bin, .coff) para  el PIC , y lo envía mediante algún puerto (serial, paralelo, USB, etc.) a un dispositivo que lo escribe en la memoria del PIC.










Prueba y verificación


En este paso nosotros debemos comprobar si el programa funciona correctamente y lo màs importante asegurarnos si realmente el PIC hace lo que nosotros queremos, si no realiza lo que queremos tenemos que regresarnos al primer paso EDITAR.


Para probarlo podemos utilizar un Protoboard, leds, cable para conexión entre mas herramientas




Bibliografìa:


Referencia1
Referencia2