bajar el doc revisión del 09/dic/2010

Reportes de Temas Avanzados

Practicas serial - USB

06/12/2010INDICE

INTRODUCCION AL LABVIEW Y MIKROC.......................................................2

Practica 1 Prueba de Eco Comunicación serial..................................................3

Práctica 2 Convertidor analógico digital de 1 canal a 10 bits mediante puerto serie.....................................................................................................................7

Práctica 3 Convertidor analógico digital de 3 canales 8 bits con comunicación por puerto serie.................................................................................................10

Práctica 4 Prueba de eco USB..........................................................................14

Práctica 5 Prueba de eco USB por medio de LabView.....................................29

Práctica 6 Convertidor analógico digital 1 canal, 8 bits por USB.......................34

Práctica 7 Convertidor analógico digital 1 canal, 10 bits por USB.....................40

Práctica 8. Convertidor analógico digital de 3 canales a 8 bits.........................46

Práctica 9. Convertidor analógico digital 1 canal, 10 bits con filtro....................53

Práctica 10. Convertidor analógico digital 3 canales con guardado de datos.. .56

Práctica 11. Control de motor reversible...........................................................59

Práctica 12. Medición de un potenciómetro y de un generador de funciones por medio de la tarjeta USB-6008...........................................................................65

Práctica 13. Frecuencímetro.............................................................................67

Práctica 14. Control de un sensor de temperatura con indicador de correo electrónico.........................................................................................................69

INTRODUCCION AL LABVIEW Y MIKROCEl LabView es un lenguaje de programación de alto nivel, de tipo gráfico, y enfocado al uso en instrumentación. Pero como lenguaje de programación, debido a que cuenta con todas las estructuras, puede ser usado para elaborar cualquier algoritmo que se desee, en cualquier aplicación, como en análisis, telemática, juegos, manejo de textos, etc. Cada programa realizado en LabView será llamado Instrumento Virtual (VI), el cual como cualesquier otro ocupa espacio en la memoria del computador.

MikroC PRO para PIC es un compilador de C para microcontroladores PIC de microchip. Esta diseñado para el desarrollo, construcción y depuración de aplicaciones integradas basadas en el PIC.

2

Practica 1 Prueba de Eco Comunicación serialObjetivo:

Construir nuestro primer circuito con el PIC18F4550 para lograr la comunicación serial por medio de labview y mikroC.

Introduccion

La comunicación serial consiste en el envío de un bit de información de manera secuencial, ésto es, un bit a la vez y a un ritmo acordado entre el emisior y el receptor.

La comunicación serial en computadores ha seguido los estándares definidos en 1969 por el RS-232 (Recommended Standard 232) que establece niveles de voltaje, velocidad de transmisión de los datos, etc. Por ejemplo, este protocolo establece un nivel de -12v como un uno lógico y un nivel de voltaje de +12v como un cero lógico (por su parte, los microcontroladores emplean por lo general 5v como un uno lógico y 0v como un cero lógico).

Existen en la actualidad diferentes ejemplos de puertos que comunican información de manera serial (un bit a la vez). El conocido como “puerto serial” ha sido gradualmente reemplazado por el puerto USB (Universal Serial Bus) que permite mayor versatilidad en la conexión de múltiples dispositivos. Aunque en naturaleza serial, no suele referenciarse de esta manera ya que sigue sus propios estándares y no los establecidos por el RS-232.

La mayoría de los microcontroladores, entre ellos los de Microchip, poseen un puerto de comunicación serial. Para comunicarse con los computadores personales actuales que poseen únicamente puerto USB requieren de un dispositivo “traductor”.

Material:

Protoboard. 1

Capacitores de 22 microfaradios 4

Capacitores de 22 picofaradios 2

Max232 1

Conector DB9 1

PIC18F4550 1

Leds 8

Resistencias de 330 ohms 8

3

http://en.wikipedia.org/wiki/Universal_Serial_Bus

http://en.wikipedia.org/wiki/Serial_port

http://c2.com/cgi/wiki?SerialPorts

http://en.wikipedia.org/wiki/RS-232

http://en.wikipedia.org/wiki/Bit

http://en.wikipedia.org/wiki/Serial_communication

Push button 1

Resistencia 10 kilo ohms 1

Cristal 8Mhz 1

Cable para protoboard.

Diagrama:

Código de programación:

char uart_rd;

void main () {

UART1_Init(9600); //inicializamos UART a 9600 bps

Delay_ms(100); //espera por UART para estabilizar

TRISB = 0; //PORTB como salidas

PORTB = 0; //apagamos todo el puerto

while (1) { //fin del ciclo

4

if (UART1_Data_Ready()) { //checamos si el dato es recibido

uart_rd = UART1_Read(); //leemos el dato recibido

PORTB = uart_rd;

UART1_Write(uart_rd); //se envia dato por el UART

}

}

}

Programacion en Labview:

5

Conclusion:

En esta práctica comenzamos a usar un nuevo PIC programando en un lenguaje avanzado como el C, usando como interfaz Labview logrando la comunicación serial entre el pic y la computadora. Viendo el resultado en el control de encendido en el puertoB.

6

Práctica 2 Convertidor analógico digital de 1 canal a 10 bits mediante puerto serie.Objetivo.

Utilizando los conocimientos de la práctica anterior realizar la conversión analógica digital de 10 bits trasmitiendo los datos por comunicación serial usando programación en C y Labview.

Introducción:

Un conversor (o convertidor) analógico-digital (CAD), (o también ADC del inglés "Analog-to-Digital Converter") es un dispositivo electrónico capaz de convertir una entrada analógica de voltaje en un valor binario, Se utiliza en equipos electrónicos como ordenadores, grabadores de sonido y de vídeo, y equipos de telecomunicaciones. La señal analógica, que varía de forma continua en el tiempo, se conecta a la entrada del dispositivo y se somete a un muestreo a una velocidad fija, obteniéndose así una señal digital a la salida del mismo.

Material:

En esta práctica seguiremos utilizando el circuito anterior agregando los siguientes dispositivos Potenciómetro 10 K y 2 Leds.

Diagrama:

Código en C

char uart_rd1, uart_rd2;

unsigned int temp_res;

unsigned int uart_wr1, uart_wr2;

7

http://es.wikipedia.org/wiki/Dispositivo

http://es.wikipedia.org/wiki/Ordenadores

http://es.wikipedia.org/wiki/Binario

http://es.wikipedia.org/wiki/Voltaje

http://es.wikipedia.org/wiki/Electr%C3%B3nica

void main() {

TRISA = 0XFF;

TRISB = 0;

TRISD = 0;

UART1_Init(9600);

Delay_ms(100);

while (1) {

if (UART1_Data_Ready()) {

temp_res = ADC_read(2);

uart_rd1 = UART1_Read();

uart_wr1 = temp_res;

UART1_Write(uart_wr1);

PORTB = uart_wr1;

Delay_ms(7);


uart_wr2 = temp_res >> 8;


PORTD = uart_wr2;

Delay_ms(7);

}

}

}


8

Conclusion:

Entre más nos metemos al entorno de programación, nos damos cuenta lo poderosa que es esta herramienta, también nos ayuda a conocer más el lenguaje de programación en C como ser capaces de diseñar una tarjeta adquiridora de datos para Labview.

9

Práctica 3 Convertidor analógico digital de 3 canales 8 bits con comunicación por puerto serie.Objetivo.

Ahora que ya sabemos hacer la conversión y mandar los datos por puerto serie, ahora se deberá de elaborar 3 convertidores a 8 bit, para ver el desempeño del PIC.

Introducción.

Un CAD muestrea una señal analógica y la convierte en un valor digital de 'n' bits. Usualmente será necesario acondicionar la señal de entrada del convertidor A-D, bien sea atenuando bien sea amplificándola.

Este muestreo está definido por la función de transferencia. En la siguiente figura se muestra una función de transferencia ideal de un convertidor de 8 bits de precisión.

Materiales:

Potenciómetros de 10 kilo con el circuito anterior

Diagrama:

10

Código en C.

char uart_rd, uart_rd1, uart_rd2;

unsigned int temp_res, temp_res1, temp_res2;

unsigned int uart_wr, uart_wr1, uart_wr2;

void main() {

TRISA = 0XFF;

TRISB = 0;

UART1_Init(9600);

Delay_ms(100);

while (1) {

if (UART1_Data_Ready()) {


uart_rd = UART1_Read();

if (uart_rd==64){

uart_wr = temp_res>> 2;

UART1_Write(uart_wr);

}

Delay_ms(7);

temp_res1 = ADC_read(2);


if (uart_rd1==65){

uart_wr1 = temp_res1>> 2;


}

Delay_ms(7);


11


if (uart_rd2==69){

uart_wr2 = temp_res2>> 2;

PORTB=uart_wr2;


}

Delay_ms(7);

}

}

}


12

Conclusión:

Como podemos ver cada convertidor tiene su propia respuesta, y esto lo logramos con la programación en C, esto se puede ver en las llaves en cada lectura. Labview nos ayuda mucho en la construcción de estas prácticas.

13

Práctica 4 Prueba de eco USB.Objetivo.

Ahora pasaremos a otro protocolo de comunicación, que en la actualidad es uno de los mas usados, en esta practica comenzaremos a profundizar la programación para lograr la comunicación USB mediante el PIC y la computadora.

Introducción.

El USB o Universal Serial Bus es una interfaz para la transmisión serie de datos y distribución de energía desarrollado por empresas líderes del sector de las telecomunicaciones y de los ordenadores y que ha sido introducida en el mercado de los PC´s y periféricos para mejorar las lentas interfaces serie (RS-232) y paralelo. Provee una mayor velocidad de transferencia (de hasta 100 veces más rápido) comparado con el puerto Paralelo de 25-pin y el Serial DB-9, DB-25, RS-232 que son los puertos que se encuentran en la mayoría de los computadores. Tenía en un principio como objetivo el conectar periféricos relativamente lentos (ratones, impresoras, cámaras digitales, unidades ZIP, etc.) de una forma realmente sencilla, rápida y basada en comunicaciones serie, aunque por sus características también podía conectarse hasta discos duros.

Materiales:

Protoboard.

PIC18F4550

Push Button

Resistencia 10 Kilo Ohms

Leds 8

Capacitores de 22 pF 2

Capacitores de 10nF

Cristal oscilador 8MHz

Conector USB (tipo A o tipo B)

Diagrama:

Colocar indicadores (Led) al puerto D

14

http://usuarios.multimania.es/kurganz/glosario.html#ZIP

http://usuarios.multimania.es/kurganz/glosario.html#RS232



Código en C

Programa Principal.

/*

* Project name:

HIDtest2 (USB HID Read & Write Test)

* Copyright:

(c) MikroElektronika, 2005-2008

* Revision History:

20050502:

- initial release;

* Description:

This example establishes connection with the HID terminal that is active

on the PC. Upon connection establishment, the HID Device Name will appear

in the respective window. The character that user sends to PIC from the HID

terminal will be re-sent back to user.

* Test configuration:

MCU: PIC18F4550

15

http://ww1.microchip.com/downloads/en/DeviceDoc/39632D.pdf

Dev.Board: EasyPIC6

http://www.mikroe.com/en/tools/easypic6/

Oscillator: HS 8.000 MHz (USB osc. is raised with PLL to 48.000MHz)

Ext. Modules: on-board USB-HID

http://www.mikroe.com/pdf/easypic6/easypic6_manual_v100.pdf#page14

SW: mikroC PRO for PIC

http://www.mikroe.com/en/compilers/mikroc/pro/pic/

* NOTES:

(*) Be VERY careful about the configuration flags for the 18F4550 - there's

so much place for mistake!

- Place jumpers J12 in the right position

*/

unsigned char k;

unsigned char userWR_buffer[64], userRD_buffer[64];

const char *text = "MIKROElektronika Compilers ER \r\n";

//**************************************************************************************************

// Main Interrupt Routine

//**************************************************************************************************

void interrupt()

{

HID_InterruptProc();

}

16

//**************************************************************************************************

//**************************************************************************************************

// Initialization Routine

//**************************************************************************************************

void Init_Main()

{

//--------------------------------------

// Disable all interrupts

//--------------------------------------

INTCON = 0; // Disable GIE, PEIE, TMR0IE,INT0IE,RBIE

INTCON2 = 0xF5;

INTCON3 = 0xC0;

RCON.IPEN = 0; // Disable Priority Levels on interrupts

PIE1 = 0;

PIE2 = 0;

PIR1 = 0;

PIR2 = 0;

ADCON1 |= 0x0F; // Configure all ports with analog function as digital

CMCON |= 7; // Disable comparators

//--------------------------------------

// Ports Configuration

//--------------------------------------

TRISA = 0xFF;

17

TRISB = 0xFF;

TRISC = 0xFF;

TRISD = 0;

TRISE = 0x07;

LATA = 0;

LATB = 0;

LATC = 0;

LATD = 0;

LATE = 0;

//--------------------------------------

// Clear user RAM

// Banks [00 .. 07] ( 8 x 256 = 2048 Bytes )

//--------------------------------------

}

//*****************************************************************************************

//*****************************************************************************************

// Main Program Routine

//*****************************************************************************************

void main() {

unsigned char i, ch;

Init_Main();

HID_Enable(&userRD_buffer, &userWR_buffer);

Delay_ms(1000); Delay_ms(1000);

while (1) {

k = HID_Read();

i = 0;

while (i < k) {

18

ch = userRD_buffer[i];

PORTD = ch;

userWR_buffer[0] = ch;

while (!HID_Write(&userWR_buffer, 1)) ;

i++;

}

}

HID_Disable();

}

//*****************************************************************************************

Programas fuente.

//******************************************************************************

//

// File Version 1.01

//

//******************************************************************************

#include "Definit.h"

#include "VARs.h"

// The number of bytes in each report,

// calculated from Report Size and Report Count in the report descriptor

unsigned char const HID_INPUT_REPORT_BYTES = 1;

unsigned char const HID_OUTPUT_REPORT_BYTES = 1;

unsigned char const HID_FEATURE_REPORT_BYTES = 2;

// Byte constants

unsigned char const NUM_ENDPOINTS = 2;

unsigned char const ConfigDescr_wTotalLength = USB_CONFIG_DESCRIPTOR_LEN + USB_INTERF_DESCRIPTOR_LEN +

19

USB_HID_DESCRIPTOR_LEN + (NUM_ENDPOINTS * USB_ENDP_DESCRIPTOR_LEN);

unsigned char const HID_ReportDesc_len = 47;

unsigned char const Low_HID_ReportDesc_len = HID_ReportDesc_len;

unsigned char const High_HID_ReportDesc_len = HID_ReportDesc_len >> 8;

unsigned char const Low_HID_PACKET_SIZE = HID_PACKET_SIZE;

unsigned char const High_HID_PACKET_SIZE = HID_PACKET_SIZE >> 8;

// Descriptor Tables

unsigned char const DescTables[USB_DEVICE_DESCRIPTOR_ALL_LEN*2] = {

// Device Descriptor

USB_DEVICE_DESCRIPTOR_LEN, 0, // bLength - Length of Device descriptor (always 0x12)

USB_DEVICE_DESCRIPTOR_TYPE, 0, // bDescriptorType - 1 = DEVICE descriptor

0x00, 0, // bcdUSB - USB revision 2.00 (low byte)

0x02, 0, // (high byte)

0x00, 0, // bDeviceClass - Zero means each interface operates independently (class code in the interface descriptor)

0x00, 0, // bDeviceSubClass

0x00, 0, // bDeviceProtocol

EP0_PACKET_SIZE, 0, // bMaxPacketSize0 - maximum size of a data packet for a control transfer over EP0

0x78, 0, // idVendor - Vendor ID (low byte)

0x56, 0, // (high byte)

0x01, 0, // idProduct - Product ID (low byte)

0x00, 0, // (high byte)

0x01, 0, // bcdDevice - ( low byte)

20

0x00, 0, // (high byte)

0x01, 0, // iManufacturer - String1

0x02, 0, // iProduct - String2

0x00, 0, // iSerialNumber - ( None )

0x01, 0, // bNumConfigurations - 1

// Configuration Descriptor

USB_CONFIG_DESCRIPTOR_LEN, 0, // bLength - Length of Configuration descriptor (always 0x09)

USB_CONFIG_DESCRIPTOR_TYPE, 0, // bDescriptorType - 2 = CONFIGURATION descriptor

ConfigDescr_wTotalLength, 0, // wTotalLength - Total length of this config. descriptor plus the interface and endpoint descriptors that are part of the configuration.

0x00, 0, // ( high byte)

0x01, 0, // bNumInterfaces - Number of interfaces

0x01, 0, // bConfigurationValue - Configuration Value

0x00, 0, // iConfiguration - String Index for this configuration ( None )

0xA0, 0, // bmAttributes - attributes - "Bus powered" and "Remote wakeup"

50, 0, // MaxPower - bus-powered draws 50*2 mA from the bus.

// Interface Descriptor

USB_INTERF_DESCRIPTOR_LEN, 0, // bLength - Length of Interface descriptor (always 0x09)

USB_INTERFACE_DESCRIPTOR_TYPE, 0, // bDescriptorType - 4 = INTERFACE descriptor

0x00, 0, // bInterfaceNumber - Number of interface, 0 based array

0x00, 0, // bAlternateSetting - Alternate setting

21

NUM_ENDPOINTS, 0, // bNumEndPoints - Number of endpoints used in this interface

0x03, 0, // bInterfaceClass - assigned by the USB

0x00, 0, // bInterfaceSubClass - Not A boot device

0x00, 0, // bInterfaceProtocol - none

0x00, 0, // iInterface - Index to string descriptor that describes this interface ( None )

// HID Descriptor

USB_HID_DESCRIPTOR_LEN, 0, // bLength - Length of HID descriptor (always 0x09)

USB_HID_DESCRIPTOR_TYPE, 0, // bDescriptorType - 0x21 = HID descriptor

0x01, 0, // HID class release number (1.01)

0x01, 0,

0x00, 0, // Localized country code (none)

0x01, 0, // # of HID class descriptor to follow (1)

0x22, 0, // Report descriptor type (HID)

Low_HID_ReportDesc_len, 0,

High_HID_ReportDesc_len, 0,

// EP1_RX Descriptor

USB_ENDP_DESCRIPTOR_LEN, 0, // bLength - length of descriptor (always 0x07)

USB_ENDPOINT_DESCRIPTOR_TYPE, 0, // bDescriptorType - 5 = ENDPOINT descriptor

0x81, 0, // bEndpointAddress - In, EP1

USB_ENDPOINT_TYPE_INTERRUPT, 0, // bmAttributes - Endpoint Type - Interrupt

Low_HID_PACKET_SIZE, 0, // wMaxPacketSize - max packet size - low order byte

High_HID_PACKET_SIZE, 0, // - max packet size - high order byte

22

1, 0, // bInterval - polling interval (1 ms)

// EP1_TX Descriptor

USB_ENDP_DESCRIPTOR_LEN, 0, // bLength - length of descriptor (always 0x07)

USB_ENDPOINT_DESCRIPTOR_TYPE, 0, // bDescriptorType - 5 = ENDPOINT descriptor

0x01, 0, // bEndpointAddress - Out, EP1

USB_ENDPOINT_TYPE_INTERRUPT, 0, // bmAttributes - Endpoint Type - Interrupt

Low_HID_PACKET_SIZE, 0, // wMaxPacketSize - max packet size - low order byte

High_HID_PACKET_SIZE, 0, // - max packet size - high order byte

1, 0, // bInterval - polling interval (1 ms)

// HID_Report Descriptor

0x06, 0, // USAGE_PAGE (Vendor Defined)

0xA0, 0,

0xFF, 0,

0x09, 0, // USAGE ID (Vendor Usage 1)

0x01, 0,

0xA1, 0, // COLLECTION (Application)

0x01, 0,

// The Input report

0x09, 0, // USAGE ID - Vendor defined

0x03, 0,

0x15, 0, // LOGICAL_MINIMUM (0)

0x00, 0,

0x26, 0, // LOGICAL_MAXIMUM (255)

0x00, 0,

23

0xFF, 0,

0x75, 0, // REPORT_SIZE (8)

0x08, 0,

0x95, 0, // REPORT_COUNT (2)

HID_INPUT_REPORT_BYTES, 0,

0x81, 0, // INPUT (Data,Var,Abs)

0x02, 0,

// The Output report


0x04, 0,


0x00, 0,


0x00, 0,

0xFF, 0,


0x08, 0,


HID_OUTPUT_REPORT_BYTES, 0,

0x91, 0, // OUTPUT (Data,Var,Abs)

0x02, 0,

// The Feature report


0x05, 0,


0x00, 0,


24

0x00, 0,

0xFF, 0,


0x08, 0,


HID_FEATURE_REPORT_BYTES, 0,

0xB1, 0, // FEATURE (Data,Var,Abs)

0x02, 0,

// End Collection

0xC0, 0 // END_COLLECTION

};

//******************************************************************************

unsigned char const LangIDDescr[8] = {

0x04, 0,

USB_STRING_DESCRIPTOR_TYPE, 0,

0x09, 0, // LangID (0x0409) - Low

0x04, 0 // - High

};

//******************************************************************************

unsigned char const ManufacturerDescr[68] = {

34, 0,


't', 0, 0, 0,

'e', 0, 0, 0,

'm', 0, 0, 0,

'a', 0, 0, 0,

's', 0, 0, 0,

25

' ', 0, 0, 0,

'a', 0, 0, 0,

'v', 0, 0, 0,

'a', 0, 0, 0,

'n', 0, 0, 0,

'z', 0, 0, 0,

'a', 0, 0, 0,

'd', 0, 0, 0,

'o', 0, 0, 0,

's', 0, 0, 0,

' ', 0, 0, 0

};

//******************************************************************************

unsigned char const ProductDescr[96] = {

48, 0,


'm', 0, 0, 0,

'i', 0, 0, 0,

'k', 0, 0, 0,

'r', 0, 0, 0,

'o', 0, 0, 0,

'C', 0, 0, 0,

' ', 0, 0, 0,

'P', 0, 0, 0,

'I', 0, 0, 0,

'C', 0, 0, 0,

' ', 0, 0, 0,

26

'1', 0, 0, 0,

'8', 0, 0, 0,

'F', 0, 0, 0,

'4', 0, 0, 0,

'5', 0, 0, 0,

'5', 0, 0, 0,

'0', 0, 0, 0,

' ', 0, 0, 0,

't', 0, 0, 0,

'e', 0, 0, 0,

's', 0, 0, 0,

't', 0, 0, 0

};

//******************************************************************************

unsigned char const StrUnknownDescr[4] = {

2, 0,

USB_STRING_DESCRIPTOR_TYPE, 0

};

// Initialization Function

void InitUSBdsc()

{

Byte_tmp_0[0] = NUM_ENDPOINTS;

Byte_tmp_0[0] = ConfigDescr_wTotalLength;

Byte_tmp_0[0] = HID_ReportDesc_len;

Byte_tmp_0[0] = Low_HID_ReportDesc_len;

Byte_tmp_0[0] = High_HID_ReportDesc_len;

Byte_tmp_0[0] = Low_HID_PACKET_SIZE;

27

Byte_tmp_0[0] = High_HID_PACKET_SIZE;

DescTables;

LangIDDescr;

ManufacturerDescr;

ProductDescr;

StrUnknownDescr;

}

Procedimiento:

Conectar el dispositivo a la computadora.

En MIKROC acceder a la ventana de pruebas HID.

HID es Human Interface Device.

Desde MikroC verificar si el dispositivo tiene comunicación con la computadora.

Conclusión:

Al desarrollar la práctica nos damos cuenta la aplicación que se le puede dar a esta comunicación, como también nos muestra la necesidad de crear driver para probar nuestro primer diseño lo cual veremos en la siguiente practica.

28

Práctica 5 Prueba de eco USB por medio de LabView.Objetivo:

Después de los conocimientos adquiridos hasta ahora, ahora utilizaremos Labview para realizar mayores aplicaciones utilizando el protocolo USB.

Introducción:

Ahora será necesario crear nuestro propio driver para poder usar a nuestro PIC como interfaz, usando labview para realizar adquisiciones de datos u otra aplicación que se le quiera dar, esto es debido, a que se trabaja con un protocolo de comunicación avanzada.

Hardware:

La misma configuración a la practica anterior

Código en C:

El archivo de código principal sigue siendo el mismo.

El archivo fuente si cambia.

Hay que modificar:

ID vendor

ID product

Mensaje de dispositivo

Los cuales nos ayudaran a la creación del driver.

Creación del controlador.

Acceder al Driver Wizard que es un complemento de LabView. Se encuentra en el folder VISA y posteriormente Driver Wizard.

De entre las opciones que inmediatamente aparecen, elegir USB.

29

Cambiar el ID vendor y el ID product; POR LOS MISMOS QUE HEMOS CAMBIADO EN NUESTRO ARCHIVO FUENTE Y QUE HEMOS YA QUEMADO EN EL PIC.

30

Si se quiere, cambiar el fabricante y el modelo del dispositivo, para crear un driver más personalizado.

31

Crearlo e instalarlo, una vez hecho esto, conectamos el dispositivo y en donde la computadora lo reconozca, actualizamos el controlador por el nuevo que acabamos de crear.

Verificar: Cuando el dispositivo deje de ser HID y pase a Dispositivo de National Instrumenst, significa que hemos hecho el proceso de manera correcta.

Programación en Labview:

32

Conclusion:

Ahora hemos creado el driver que nos ayudara a la elaboración de las siguientes practicas, con esto y el programa de ECO hemos dado un paso a la programación con USB.

33

Práctica 6 Convertidor analógico digital 1 canal, 8 bits por USB.Objetivo.

Una vez teniendo los conocimientos de programación como en C y en labview, nuestra próxima escena será repetir las practicas de protocolo serie ahora con el protocolo usb.

Introducción.

Hay que recordar que la configuración del convertidor en MIKROC es bastante sencilla, ahora teniendo esa topología en mente y uniéndola con la prueba de eco USB obtendremos una adquisición de datos analógicos bastante fiel y rápida. Finalmente cabe mencionar que el tamaño del convertidor es de 10 bits, y necesitamos solo la parte mas alta ya que si no, obtendremos una señal que re circulará en los mismos valores 4 veces.

Materiales:

Circuito de la practica 4

Potenciómetro de 10Kohms

Diagrama:

Realizar el circuito de la practica 4 conectando los dispositivos de adquisición como en la práctica del convertidor.

Código C

Programa principal.

/*

* Project name:


* Copyright:


* Revision History:

20050502:

34

- initial release;

* Description:






MCU: PIC18F4550


Dev.Board: EasyPIC6







* NOTES:




*/

unsigned char k;




//*****************************************************************************************

35


//*****************************************************************************************

void interrupt()

{


}

//****************************************************************************

//*****************************************************************************************


//****************************************************************************

void Init_Main()

{

//--------------------------------------


//--------------------------------------


INTCON2 = 0xF5;

INTCON3 = 0xC0;


PIE1 = 0;

PIE2 = 0;

PIR1 = 0;

PIR2 = 0;

ADCON1 |= 0x00; // Configure all ports with analog function as digital (0X0F - Valor previo)


//--------------------------------------

36


//--------------------------------------

TRISA = 0xFF;

TRISB = 0xFF;

TRISC = 0xFF;

TRISD = 0;

TRISE = 0x07;

LATA = 0;

LATB = 0;

LATC = 0;

LATD = 0;

LATE = 0;

//--------------------------------------

// Clear user RAM

// Banks [00 .. 07] ( 8 x 256 = 2048 Bytes )

//--------------------------------------

}

//****************************************************************************


//****************************************************************************

void main() {

unsigned char i, ch;

Init_Main();



while (1) {

k = HID_Read();

37

i = 0;

while (i < k) {



PORTD = temp_res>> 2;

userWR_buffer[0] = temp_res>> 2;


i++;

}

}

HID_Disable();

}

//****************************************************************************


38

Conclusión:

Ahora vemos un mejor resultado con el muestreo de nuestros datos adquiridos del potenciómetro, eso se debe al protocolo de comunicación, con esto podemos ver la practicidad del USB.

39

Práctica 7 Convertidor analógico digital 1 canal, 10 bits por USB.Objetivo:

Realizaremos la misma práctica de conversión a 10 bits realizando la comunicación USB en vez de la serial.

Introducción:

Vimos la facilidad de pasar de un protocolo a otro, gracias a la ayuda del lenguaje C y por la herramienta Labview, ahora seguimos nuestro paso realizando la práctica de convertidor analógico digital a 10 bits.

Material:

El mismo circuito de la practica 6 agregando dos leds mas para ver la conversión a 10 bits.

Diagrama.

La misma conexión de la practica anterior solo agregando dos leds mas como en la practica del conversor comunicación serial.

Código en C.

/*

* Project name:


* Copyright:


* Revision History:

20050502:

- initial release;

* Description:




40



MCU: PIC18F4550


Dev.Board: EasyPIC6







* NOTES:




*/

unsigned char k;




//*****************************************************************************************


//*****************************************************************************************

void interrupt()

{


41

}

//*****************************************************************************************

//*****************************************************************************************


//*****************************************************************************************

void Init_Main()

{

//--------------------------------------


//--------------------------------------


INTCON2 = 0xF5;

INTCON3 = 0xC0;


PIE1 = 0;

PIE2 = 0;

PIR1 = 0;

PIR2 = 0;



//--------------------------------------


//--------------------------------------

TRISA = 0xFF;

TRISB = 0;

TRISC = 0xFF;

42

TRISD = 0;

TRISE = 0x07;

LATA = 0;

LATB = 0;

LATC = 0;

LATD = 0;

LATE = 0;

//--------------------------------------

// Clear user RAM

// Banks [00 .. 07] ( 8 x 256 = 2048 Bytes )

//--------------------------------------

}

//*****************************************************************************************

//*****************************************************************************************


//*****************************************************************************************

void main() {

unsigned char i, ch, ch2;

Init_Main();


Delay_ms(1000); Delay_ms(1000)

while (1) {

k = HID_Read();

i = 0;

while (i < k) {


if (ch == 0X01) {

43


PORTD = temp_res;

userWR_buffer[0] = temp_res;

}

Delay_ms(7);

ch2 = userRD_buffer[i];

if (ch2 == 0x08) {

PORTB = temp_res >> 8;

userWR_buffer[0] = temp_res >> 8;

}


i++;

}

}

HID_Disable();

}

//*****************************************************************************************


44

Conclusión:

La conversión a 10 bits nos da mejor respuesta debido a la resolución. Lo que se observo en la practica fueron perturbaciones debido al ruido entregado del mismo potenciómetro.

45

Práctica 8. Convertidor analógico digital de 3 canales a 8 bits.Objetivo.

Profundizar mas en el protocolo USB usando lenguaje C y la herramienta Labview para realizar un manejo de mayor cantidad de datos.

Introducción.

Llevaremos a la práctica los conocimientos obtenidos al programar el protocolo serie, ahora en un protocolo más rápido y eficaz.

Materiales:

Realizar las conexiones de la práctica de comunicación serie convertidor analógico conectando para realizar la comunicación serie como en la primer practica.

Código en C.

/*

* Project name:


* Copyright:


* Revision History:

20050502:

- initial release;

* Description:






46

MCU: PIC18F4550


Dev.Board: EasyPIC6







* NOTES:




*/

unsigned char k;


unsigned int temp_res, temp_res1, temp_res2;


//*****************************************************************************************


//*****************************************************************************************

void interrupt()

{


}

//*****************************************************************************************

47

//*****************************************************************************************


//*****************************************************************************************

void Init_Main()

{

//--------------------------------------


//--------------------------------------


INTCON2 = 0xF5;

INTCON3 = 0xC0;


PIE1 = 0;

PIE2 = 0;

PIR1 = 0;

PIR2 = 0;



//--------------------------------------


//--------------------------------------

TRISA = 0xFF;

TRISB = 0;

TRISC = 0xFF;

TRISD = 0;

TRISE = 0x07;

48

LATA = 0;

LATB = 0;

LATC = 0;

LATD = 0;

LATE = 0;

//--------------------------------------

// Clear user RAM

// Banks [00 .. 07] ( 8 x 256 = 2048 Bytes )

//--------------------------------------

}

//*****************************************************************************************


//*****************************************************************************************

void main() {

unsigned char i, ch, ch2, ch3 ;

Init_Main();



while (1) {

k = HID_Read();

i = 0;

while (i < k) {


if (ch == 0X01) {


userWR_buffer[0] = temp_res>> 2;

}

49

Delay_ms(7);


if (ch2 == 0x08) {


userWR_buffer[0] = temp_res1>> 2;

}

Delay_ms(7);


if (ch3 == 0x0F) {


userWR_buffer[0] = temp_res2>> 2;

}


i++;

}

}

HID_Disable();

}

Programación con labview:

50

Conclusión:

Podemos ver la cantidad de datos y la velocidad con la cual se puede trabajar con el protocolo USB.

52

Práctica 9. Convertidor analógico digital 1 canal, 10 bits con filtro.Objetivo:

Ahora vamos a introducir un filtro para obtener una mejor respuesta a la señal de salida de nuestro convertidor de 10 bits, el filtro se trabajara en labview.

Introducción:

Como pudimos ver en la respuesta de la señal entrega por nuestro potenciómetro obtuvimos ruido, ahora nuestro propósito es eliminar ese ruido utilizando un filtro para lograr una mejor fidelidad.

Material:

Circuito de práctica 7

Diagrama:

El circuito se usara sin cambios.

Código en C.

También usaremos el mismo código que en la práctica 7.


53

Conclusión:

Al llevar a cabo esta práctica podemos ver el cambio entre la señal de entrada en la práctica anterior a la actual esto gracias al filtro. Nos damos cuenta que un filtro no en necesariamente colocar un capacitor y una resistencia o usando opam, sino que también lo podemos realizar mediante software.

55

Práctica 10. Convertidor analógico digital 3 canales con guardado de datos.Objetivo.

Ahora sacaremos una de las muchas funciones de Labview para ir completando nuestras prácticas y así obtener mayor conocimiento en la programación.

Introducción.

Agregar esta característica a la tarjeta es importante, ya que los valores de los sensores pueden ser guardados en un archivo y así ser revisados más tarde.

No sólo eso, también podemos hacer operaciones, promedios, filtros y todo el análisis que se necesite y lo hacemos con valores muy exactos, continuos y fieles.

Material:

Circuito de práctica 8.

Diagrama:

Seguiremos usando el armado del circuito anterior

Código en C.

Seguiremos usando el mismo código de programación.


56

Conclusión:

Usamos una herramienta de Labview para guardar los datos obtenidos de la medición, así vamos conociendo mas nuestra interfaz.

58

Práctica 11. Control de motor reversible.Objetivo.

Usando los conocimientos obtenidos hasta el momento para realizar el control de un motor usando lógica PLC.

Introducción.

Usar la metodología de programación de escalera para lograr el giro del motor.

Material:

Circuito práctica 5.

LM293B

Motor de corriente directa a 5volts.

Push Button 3

1 Fusible.

Código en C.

/*

* Project name:


* Copyright:


* Revision History:

20050502:

- initial release;

* Description:





59


MCU: PIC18F4550


Dev.Board: EasyPIC6







* NOTES:




*/

unsigned char k;



//*****************************************************************************************


//*****************************************************************************************

void interrupt()

{


}

//*****************************************************************************************

60

//*****************************************************************************************


//*****************************************************************************************

void Init_Main()

{

//--------------------------------------


//--------------------------------------


INTCON2 = 0xF5;

INTCON3 = 0xC0;


PIE1 = 0;

PIE2 = 0;

PIR1 = 0;

PIR2 = 0;

ADCON1 |= 0x0F; // Configure all ports with analog function as digital


//--------------------------------------


//--------------------------------------

TRISA = 0xFF;

TRISB = 0xFF;

TRISC = 0xFF;

TRISD = 0;

TRISE = 0x07;

61

LATA = 0;

LATB = 0;

LATC = 0;

LATD = 0;

LATE = 0;

//--------------------------------------

// Clear user RAM

// Banks [00 .. 07] ( 8 x 256 = 2048 Bytes )

//--------------------------------------

}

//*****************************************************************************************

//*****************************************************************************************


//*****************************************************************************************

void main() {

unsigned char i, ch, ch1;

Init_Main();



while (1) {

k = HID_Read();

i = 0;

while (i < k) {


PORTD = ch;

ch1 = PORTB;

userWR_buffer[0] = ch1;

62


i++;

}

}

HID_Disable();

}

//*****************************************************************************************

Programación en labview:

63

Resultados.

Podemos ver lo poderoso que es saber usar una herramienta como el Labview para poder controlar un motor usando la lógica de escalera, claro este gracias a acoplar al pic con un programa en lenguaje c usando mikroc.

64

Práctica 12. Medición de un potenciómetro y de un generador de funciones por medio de la tarjeta USB-6008.Objetivo.

Aprender a usar una nueva interfaz para conocer la diferencia de programación asi como todas las utilidades de la tarjeta.

Introducción.

Las tarjetas DAQ NI USB-6008 y NI USB-6009 tienen capacidades multifunción con ocho canales de entrada analógica 12 ó 14 bits, dos salidas analógicas, 12 líneas E/S digitales y un contador. Ambos dispositivos funcionan con la corriente del bus USB así que no necesitan una fuente de energía externa para trabajar. Incluyen terminales de tornillo para extraíbles para conectarse por señal directa, una referencia de tensión de abordo para suministrar energía a dispositivos y sensores externos, una capa diseñada en cuatro capas para reducir el ruido y aumentar la precisión, así como para proteger contra sobretensión en las líneas de entrada analógica de hasta ±35 V.

Material:

USB-6008

Potenciómetro

Generador de funciones.

Diagrama:

Colocaremos la salida del potenciómetro a la salida AI0 y lo alimentaremos con la fuente incluida en la tarjeta. El generador de funciones entrara en AI1+ y AI1- para usar el modo diferencial.


65

Conclusion:

Conocer las interfaces realizadas por national instruments y ver la diferencia de practicidad entre la daq profesional o una hecha por nosotros.

66

Práctica 13. Frecuencímetro.Objetivo.

Con la tarjeta de National construir un dispositivo capaz de medir la frecuencia de la señal de entrada.

Introducción.

Un frecuencímetro es un instrumento que sirve para medir la frecuencia, contando el número de repeticiones de una onda en un intervalo de tiempo, mediante el uso de un contador que acumula el número de periodos. Dado que la frecuencia se define como el número de eventos de una clase particular ocurridos en un período, es generalmente sencilla su medida.Hardware.

Materiales.

USB 6008

Generador de funciones.

Diagrama.

Conectaremos el generador de funciones a la entrada diferencial AI1.

Programación en Labview

67

http://es.wikipedia.org/wiki/Frecuencia

Conclusión:

Vemos la facilidad de procesar una señal con la ayuda de la tarjeta USB 6008 realizando un frecuencímetro acercándonos al comportamiento de un osciloscopio.

68

Práctica 14. Control de un sensor de temperatura con indicador de correo electrónico.Objetivo:

Diseñar y construir un sistema telemétrico con el fin de monitorear la temperatura, checando los datos obtenidos, si el dato es mayor a la temperatura que se exponga enviara un correo avisando que se a llegado al límite y parara el proceso.

Introducción.

En esta práctica veremos otra aplicación de Labview, la cual es poder mandar un correo a un servidor.

Material:

USB-6008

LM35

Diagrama:

Alimentar el sensor con la tarjeta USB-6008

La salida conectarla a AI0, en modo SEF.

Block Diagram

69

Conclusión:

Vemos la facilidad de hacer un sistema telemétrico usando la interfaz USB 6008 y la herramienta de Labview para censar la temperatura y mandar un correo con los datos obtenidos en la medición.

70

bajar el doc revisión del 09/dic/2010

Documents