About This Blog

Este es un blog dedicado al módulo de "Desarrollo y Construcción de Prototipos Electrónicos", el cual pertenece al segundo año del ciclo "Desarrollo de productos electrónicos", en el que se irá colgando cualquier tema que sea abordado en dicho ciclo.

Medir un objeto con visión artificial

Posted by Diego Lavín 11:10, under , | 1 comment

El ejercicio consiste en medir la longitud de un objeto utilizando el programa Vision Builder 2009.
Utilizando este programa y una webcam seremos capaces de saber la longitud de cualquier objeto que pase ante la cam en tiempo real.
El primer paso que debemos hacer es seleccionar la cámara que vamos a utilizar:


Una vez seleccionada debemos filtrar la imagen, ya que algunos de los pasos que vamos a realizar así lo exigen. Para ello nos vamos a la pestaña Inspection Steps: Enhance Images y escogemos la opción de Vision Assistant, cuando nos pregunte por la región de interes marcamos Full Image y luego vamos a Edit. Aquí se nos abre una nueva ventana con otra aplicación de Vision. En esta lo que vamos a hacer va a ser extraer el color


Ahora ya podemos seguir.
El siguiente paso va a ser calibrar la imagen. Podemos poner una regla en frente de la cámara y así calibrar la distancia que deseemos.
Una vez hecha la calibración, escogeremos la opción Caliper para seleccionar la zona donde queremos que se realize la medición.



Lo último que nos queda es mostrar la medida, teniendo como referencia la calibración hecha anteriormente.



Ya está finalizado, ahora podemos poner un objeto y nos lo medirá en tiempo real

DESCARGA EL EJERCICIO


Comunicación SPI entre PIC´s

Posted by Diego Lavín 17:06, under | 3 comments

En este ejercicio vamos a comunicar dos PIC18F4550, utilizando el bus SPI (Serial Peripheral Interface)
Como en el ejercicio anterior vamos a utilizar el CCS C para programar y compilar en C y el Proteus 7.7 sp2 para simular el circuito. Finalmente usaremos el Ares para diseñar el pcb y ver como quedaría finalmente.

En este caso existen dos PIC´s, por lo que tendrá que haber dos progrmas distintos, uno para cada pic. El primero actuará como maestro que se encargará de mandar un dato al otro pic, el esclavo que leerá el dato.
En la imagen se ve como en el primer pic (maestro) hay un switch y en el segundo (esclavo) hay un diodo led rojo, el otro símplemente es de prueba. Cuando el switch está activado se enciende el led, por lo que está habiendo una comunicación entre pic´s.



El código del maestro, en el que configuro el pic como maestro para el uso del SPI y escribo en un pin:

/////////////////////////////////////////////////////////////////////////////////////
//   AUTOR: Diego Lavín                        Febrero/2011 
/////////////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:   Comunicación entre PICs                   VERSIÓN:    1.0
//   DISPOSITIVO: PIC18F4550                                          COMPILADOR: CCS vs4.93
//   Entorno IDE:                                                                     SIMULADOR:  Proteus 7.7 sp2
//   TARJETA DE APLICACIÓN:                                         DEBUGGER:  
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//Comunicar 2 PICs 18F4550 utilizando el protocolo SPI. Cuando hay un "1" lógico
//en el pin ra1 se enciende un diodo led.
//
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//CABECERA///////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
#include < 18f4550.h>                  //pic a utilizar
#fuses inths                                    //oscilador interno
#use delay(internal=8Mhz)           //frecuencia del oscilador

/////////////////////////////////////////////////////////////////////////////////////
//VARIABLES GLOBALES////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//FUNCIONES/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//PRINCIPAL/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
void main( )
{
   setup_spi(spi_master | spi_l_to_h | spi_clk_div_16);    //configurar spi como maestro
   while(1)
   {
    //  spi_write(input(pin_a0));    //escribir en el pin ra0
      spi_write(input(pin_a1));    //escribir en el pin ra1
      delay_ms(1000);
   }





Código del esclavo, aquí configuro el pic como esclavo y leo continuamente si hay dato en el SPI y si le hay que active el puerto c como salida:

/////////////////////////////////////////////////////////////////////////////////////
//   AUTOR: Diego Lavín                        Febrero/2011 
/////////////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:   Comunicación entre PICs                   VERSIÓN:    1.0
//   DISPOSITIVO: PIC18F4550                                          COMPILADOR: CCS vs4.93
//   Entorno IDE:                                                                     SIMULADOR:  Proteus 7.7 sp2
//   TARJETA DE APLICACIÓN:                                         DEBUGGER:  
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//Comunicar 2 PICs 18F4550 utilizando el protocolo SPI. Cuando hay un "1" lógico
//en el pin ra1 se enciende un diodo led.
//
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//CABECERA///////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
#include < 18f4550.h>                  //pic a utilizar
#fuses inths                                    //oscilador interno
#use delay(internal=8Mhz)           //frecuencia del oscilador

/////////////////////////////////////////////////////////////////////////////////////
//VARIABLES GLOBALES////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//FUNCIONES/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//PRINCIPAL/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
void main()
{
   setup_spi(spi_slave | spi_l_to_h | spi_clk_div_16);     //configurar spi como esclavo
   for(;;)
   {
      if(spi_data_is_in())      //si hay un dato en el spi
      {      
         //output_d(spi_read()); 
         output_c(spi_read());
      }
   }
}

Vista en Ares y como dije anteriormente cuidado con los packages de los componentes porque pueden faltar al no haber sido asignados en el Proteus o porque no existe package de ese componente:




3D:









DESCARGA EL EJERCICIO

LCD gráfico y PIC18F4550

Posted by Diego Lavín 16:32, under | 4 comments

En esta práctica vamos a utilizar un LCD gráfico, el cual será controlado por un PIC18F4550. La programación la llevaremos a cabo con el CCS C Compiler y la posterior simulación será realizada con Proteus (7.7 sp2).



En Proteus podeis encontrar varios tipos de LCD gráfico pero en mi caso he utilizado el LGM12641BS1R.
Ahora vamos a empezar con la programación del PIC, para ello debemos de crear un nuevo proyecto desde el CCS C y empezar con la programación en sí.

El código programado en el PIC es el siguiente:

/////////////////////////////////////////////////////////////////////////////////////
//   AUTOR: Diego Lavín                        Febrero/2011 
/////////////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:   LCD Gráfico                    VERSIÓN:    1.0
//   DISPOSITIVO: PIC18F4550                   COMPILADOR: CCS vs4.93
//   Entorno IDE:                                              SIMULADOR:  Proteus 7.7 sp2
//   TARJETA DE APLICACIÓN:                  DEBUGGER:  
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//Muestra distintos caracteres por un lcd gráfico
//
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//CABECERA///////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
#include <18F4550.h>
#fuses inths                               //oscilador interno
#use delay(internal=8Mhz)      //frecuencia del oscilador
#include < hdm64gs12.c>        //drivers lcd
#include < graphics.c>         //contiene funciones para dibujar círculos, lineas...

/////////////////////////////////////////////////////////////////////////////////////
//VARIABLES GLOBALES////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
char voltext[ ]="Diego";       //introduzco variables para introducir texto
char voltext3[ ]="Lavin";
char voltext2[ ]="2011";

/////////////////////////////////////////////////////////////////////////////////////
//FUNCIONES/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////
//PRINCIPAL/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
void main( )
{
   glcd_init(on);                                         //enciende lcd
   glcd_line(20,47,80,53,on);                    //dibuja una linea
   glcd_rect(100,5,120,20,yes,ON);        // dibuja un rectángulo con relleno
   glcd_text57(1,1,voltext,1,ON);            //introduzco las variables de texto
   glcd_text57(35,1,voltext3,1,ON);
   glcd_text57(100,55,voltext2,1,ON);
  
   glcd_circle(30,25,15,no,on);              //dibuja círculo       
   glcd_circle(30,24,5,yes,ON);            //dibuja un círculo con  relleno
   glcd_circle(70,25,15,no,on);
   glcd_circle(70,24,5,yes,ON);

 
Ahora vamos a ver como queda la placa una vez finalizada. Hay que tener precaución con los packages usados en Proteus ya que algunos componentes no tienen o no se puede simular por lo que hay que deshabilitarlo para que la simulación se realize correctamente. De todas maneras en el Ares se pueden modificar los Footprints para que aquí ya sean los definitivos. 

Vista en Ares:
Vista en 3D:

Generar y leer una señal analógica

Posted by Diego Lavín 14:30, under | No comments

Como en anteriores ejercicios, utilizando un DAQ 6008 y Labview, debemos generar una señal analógica y luego leerla.

Este ejercicio, para entenderlo mejor estará dvidido en dos partes. La primera que será donde genero la función deseada, símplemente usando un generador de señales. Luego esta señal estará configurada como salida analógica para así en la segunda parte del ejercicio poder leerla como un dato de entrada. 



Viendo el panel frontal nos encontramos dos Wavefrom Chart, el primero correspone a la función generada y el de abajo a la leida. Habrá que jugar con el rate y the samples per channel para obtener la configuración mas satisfactoria.

DESCARGA EL EJERCICIO


Múltiples canales con DAQ 6008

Posted by Diego Lavín 19:07, under | No comments

Utilizando un DAQ 6008 y Labview, debemos de leer varios canales (5 en mi caso).


Lo primero que debemos hacer es ir al MAX para configurar cada canal que vayamos a utilizar. Así evitaremos futuros conflictos entre los canales usados.

Como se ve he configurado una tarea con los 5 canales que voy a utilizar para llevar a cabo esta práctica.

 El código es muy sencillo, ya que tenemos nuestra entrada analógica (voltage) al cual le asignamos la tarea previamente hecha con el MAX, en el que está la configuración de nuestros canales.

Si pasamos al Front Panel veremos como podemos leer la distintas tensiones que tenemos en cada canal al mismo tiempo.