Proyecto Final

Tema: Programacin de Puertos

Materia: Arquitectura de
Computadoras
Alumnos: Jose Arturo Romero
Juan Pablo Villazon

SANTA CRUZ - B OLIVIA

INTRODUCCION.Durante mucho tiempo, las computadoras no han formado parte activa

en los procesos industrials a pesar de que son una herramienta
indispensable en estos dias, con este proyecto nosotros pretendemos
mostrar la utilidad y eficiencia que pueden tener dandonos una solucion
integral, economica y sencilla.
1.- Objetivos.

Realizar el montaje de un dispenser de agua con la ayuda del

puerto USB.
Utilizar la programacin de pic y de puerto usb para el control del
dispenser.

2.- Marco Terico.En la informtica, un puerto ata puerto es una forma genrica de
denominar a una interfaz a travs de la cual los diferentes tipos de datos
se pueden enviar y recibir. Dicha interfaz puede ser de tipo fsico, o
puede ser a nivel de software (por ejemplo, los puertos que permiten la
transmisin de datos entre diferentes ordenadores) (ver ms abajo para
ms detalles), en cuyo caso se usa frecuentemente el trmino puerto
lgico.
El Universal Serial Bus (bus universal en serie), abreviado
comnmente USB, es un puerto que sirve para conectar perifricos a un
ordenador. Fue creado en 1996 por siete empresas (que actualmente
forman el consejo directivo): IBM, Intel, Northern Telecom, Compaq,
Microsoft, Digital Equipment Corporation y NEC.

Smbolo convencional del puerto USB

Un puerto USB permite conectar hasta 127 dispositivos y ya es un

estndar en los ordenadores de ltima generacin, que incluyen al
menos cuatro puertos USB 2.0 en los ms modernos, y algn USB 1.1 en
los mas anticuados. El USB puede conectar varios tipos de dispositivos
como pueden ser: mouse, teclados, escneres, cmaras digitales,
telfonos mviles, reproductores multimedia, impresoras, discos duros
externos entre otros ejemplos, tarjetas de sonido, sistemas de
adquisicin de datos y componentes de red. Para dispositivos
multimedia como escneres y cmaras digitales, el USB se ha convertido
en el mtodo estndar de conexin. Para impresoras, el USB ha crecido
tanto en popularidad que ha desplazado a un segundo plano a los
puertos paralelos porque el USB hace mucho ms sencillo el poder
agregar ms de una impresora. El USB casi ha reemplazado
completamente a los teclados y mouses (ratones) PS/2, hasta el punto
que un amplio nmero de placas base modernas carecen de dicho
puerto o solamente cuentan con uno vlido para los dos perifricos.
Pero qu otras ventajas ofrece este puerto? Es totalmente Plug & Play,
es decir, con slo conectar el dispositivo y "en caliente" (con el
ordenador ya encendido), el dispositivo es reconocido, e instalado, de
manera inmediata. Slo es necesario que el Sistema Operativo lleve
incluido el correspondiente controlador o driver. Presenta una alta
velocidad de transferencia en comparacin con otro tipo de puertos. USB
1.1 alcanza los 12 Mb/s y hasta los 480 Mb/s (60 MB/s) para USB 2.0,
mientras un puerto serie o paralelo tiene una velocidad de transferencia
inferior a 1 Mb/s. El puerto USB 2.0 es compatible con los dispositivos
USB 1.1

A travs del cable USB no slo se transfieren datos; adems es posible

alimentar dispositivos externos. El consumo mximo de este controlador
es de 2.5 Watts. Los dispositivos se pueden dividir en dispositivos de
bajo consumo (hasta 100 mA) y dispositivos de alto consumo (hasta 500
mA). Para dispositivos que necesiten ms de 500 mA ser necesaria
alimentacin externa. Hay que tener en cuenta, adems, que si se utiliza
un concentrador y ste est alimentado, no ser necesario realizar
consumo del bus. Una de las limitaciones de este tipo de conexiones es
que longitud del cable no debe superar los 5 ms y que ste debe cumplir
las especificaciones del Standard USB iguales para la 1.1 y la 2.0
Los dispositivos USB se clasifican en cuatro tipos segn su velocidad de
transferencia de datos:

Baja velocidad (1.0): Tasa de transferencia de hasta 1,5 Mbps (192

KB/s). Utilizado en su mayor parte por dispositivos de interfaz
humana (Human Interface Device, en ingls) como los teclados,
los ratones (mouse), las cmaras web, etc.

Velocidad completa (1.1): Tasa de transferencia de hasta 12 Mbps

(1,5 MB/s) segn este estndar, pero se dice en fuentes
independientes que habra que realizar nuevamente las
mediciones. sta fue la ms rpida antes de la especificacin USB
2.0, y muchos dispositivos fabricados en la actualidad trabajan a
esta velocidad. Estos dispositivos dividen el ancho de banda de la
conexin USB entre ellos, basados en un algoritmo de impedancias
LIFO.

Alta velocidad (2.0): Tasa de transferencia de hasta 480 Mbps (60

MB/s) pero por lo general de hasta 125Mbps (16MB/s). Est
presente casi en el 99% de los PC actuales. El cable USB 2.0
dispone de cuatro lneas, un par para datos, una de corriente y un
cuarto que es el negativo o retorno.

Super alta velocidad (3.0): Tiene una tasa de transferencia de

hasta 4.8 Gbps (600 MB/s). La velocidad del bus es diez veces ms
rpida que la del USB 2.0, debido a que han incluido 5 conectores
extra, desechando el conector de fibra ptica propuesto
inicialmente, y ser compatible con los estndares anteriores. usa
un cable de 9 hilos. En Octubre de 2009 la compaa taiwanesa
ASUS lanz la primera placa base que inclua puertos USB3, tras

ella muchas otras le han seguido y se espera que en 2012 ya sea

el estndar de facto.

USB 3.0.- La principal caracterstica es la multiplicacin por 10 de la

velocidad de transferencia, que pasa de los 480 Mbps a los 4,8 Gbps
(600
MB/s).
Otra de las caractersticas de este puerto es su "regla de inteligencia":
los dispositivos que se enchufan y despus de un rato quedan en
desuso, pasan inmediatamente a un estado de bajo consumo.
A la vez, la intensidad de la corriente se incrementa de los 500 a los 900
miliamperios, que sirve para abastecer a un telfono mvil o un
reproductor
audiovisual
porttil
en
menos
tiempo.
Por otro lado, aumenta la velocidad en la transmisin de datos, ya que
en lugar de funcionar con tres lneas, lo hace con cinco. De esta manera,
dos lneas se utilizan para enviar, otras dos para recibir, y una quinta se
encarga de suministrar la corriente. As, el trfico es bidireccional (Full
dplex).

USB 3.0
3.- Instrumentos y herramientas usadas:

PIC 16F8550
Resistencias
Pulsadores
Leds
Condensadores
Reles
Cristal
Diodo
Sensores de temperatura
Fin de carrera
Contactor 220
Sensor de nivel industrial
Conector usb
Electrovlvula
Soporte para recipiente

Esquema.-

Interfaz.-

Codificacin de Interfaz (C#).using System;

using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using MecaniqueUK;

namespace WindowsFormsApplication1
{
public partial class USB_FORM : Form

UInt32 controlador;
uint ADCValue1 = 0;
uint ADCValue2 = 0;

public USB_FORM()
{
InitializeComponent();

private void FormMain_Load_1(object sender, EventArgs e)

{
deshabilita_controles();
}

private void FormMain_FormClosed(object sender, FormClosedEventArgs e)

{
EasyHID.Disconnect();
}

private void Dispositivo_Conectado(UInt32 handle)

{
if (EasyHID.GetVendorID(handle) == EasyHID.VENDOR_ID && EasyHID.GetProductID(handle) ==
EasyHID.PRODUCT_ID)
{
EasyHID.SetReadNotify(handle, true);
controlador = handle;
}
}

private void Dispositivo_desconectado(UInt32 handle)

{

if (EasyHID.GetVendorID(handle) == EasyHID.VENDOR_ID && EasyHID.GetProductID(handle) ==

EasyHID.PRODUCT_ID)
{
CONECTAR_DISPOSITIVO.BackColor = Color.Red;
CONECTAR_DISPOSITIVO.ForeColor = Color.White;
CONECTAR_DISPOSITIVO.Text = "CONECTAR DISPOSITIVO";
deshabilita_controles();
EasyHID.Disconnect();
}
}

private void Lee_datos(UInt32 In_handle)

{
byte[] BufferINP = new byte[EasyHID.BUFFER_IN_SIZE];
if ((EasyHID.Read(In_handle, out BufferINP)) == true)
{
if (BufferINP[1] == 0x01)
{

TANQUE_LLENO.Visible = true;
TANQUE_VACIO.Visible = false;
}
else {
TANQUE_LLENO.Visible = false;
TANQUE_VACIO.Visible = true;
}

if (BufferINP[2] == 0x01)
{
IN_DIGITAL_2.BackColor = Color.Red;
LBL_REC.Text = "NO HAY RECIPIENTE";

}
else

{
IN_DIGITAL_2.BackColor = Color.Green;
LBL_REC.Text = "SI HAY RECIPIENTE";

}
if (BufferINP[2] != 0x01 && BufferINP[1] == 0x01)
{
OUT_ELECTROVALVULA.Enabled = true;
}
else
{
OUT_ELECTROVALVULA.Enabled = false;
}

ADCValue1 = (uint)(BufferINP[5] << 8) + BufferINP[6];

LBL_TEMP.Text = Convert.ToString((int)ADCValue2/2);

}
}

protected override void WndProc(ref Message message)

{
if (message.Msg == EasyHID.WM_HID_EVENT)
{
switch (message.WParam.ToInt32())
{
case EasyHID.NOTIFY_PLUGGED:
Dispositivo_Conectado((UInt32)message.LParam.ToInt32());
break;
case EasyHID.NOTIFY_UNPLUGGED:
Dispositivo_desconectado((UInt32)message.LParam.ToInt32());

break;
case EasyHID.NOTIFY_READ:
Lee_datos((UInt32)message.LParam.ToInt32());
break;
}
}
base.WndProc(ref message);
}

private void OUT_DIGITAL_1_Click(object sender, EventArgs e)

{
byte[] BufferOUT = new byte[EasyHID.BUFFER_OUT_SIZE];
BufferOUT[0] = 0;
BufferOUT[1] = 0x0A;

BufferOUT[2] = 0x10;
EasyHID.Write(controlador, BufferOUT);
}

private void CONECTAR_DISPOSITIVO_Click(object sender, EventArgs e)

{
EasyHID.Connect(Handle);
habilita_controles();
CONECTAR_DISPOSITIVO.Text = "DISPOSITIVO CONECTADO";
CONECTAR_DISPOSITIVO.BackColor = Color.GreenYellow;
CONECTAR_DISPOSITIVO.ForeColor = Color.Black;
BTN_DESCONECTAR.Enabled = true;
}

private void salirToolStripMenuItem_Click(object sender, EventArgs e)

{
EasyHID.Disconnect();

this.Close();
}

private void habilita_controles()

{

OUT_ELECTROVALVULA.Enabled = true;
}

private void deshabilita_controles()

{
OUT_ELECTROVALVULA.Enabled = false;

private void LBL_TEMP_Click(object sender, EventArgs e)

{

private void button1_Click(object sender, EventArgs e)

{

private void TANQUE_VACIO_Click(object sender, EventArgs e)

{

private void BTN_DESCONECTAR_Click(object sender, EventArgs e)

{
EasyHID.Disconnect();
deshabilita_controles();

Firmware (pic).#include <18F2550.h>

#DEVICE ADC=10
#fuses NOMCLR,HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,NOPBADEN
#use delay(clock=48000000)
#include <pic18_usb.h>
#include <APLICACION_HID.h>
#include <Descriptor_easyHID.h>
#include <USB.c>

#use fast_io(b)
#use fast_io(c)

void USB_debug(){

LED_ON(LED_RED);
LED_OFF(LED_GREEN);
usb_wait_for_enumeration();
LED_ON(LED_GREEN);
LED_OFF(LED_RED);
}

void config_adcon2(void) {
#asm
movlw 0b10111110
iorwf 0xFC0,1
#endasm
}

void main(void)
{

int8

recibe[USB_EP1_RX_SIZE];

int8

envia[USB_EP1_TX_SIZE];

int8

valorPWM1_H=0;

int8

valorPWM2_H=0;

int8

valorPWM1_L=0;

int8

valorPWM2_L=0;

int8

valorPWM1=0;

int8

valorPWM2=0;

int8

valor_adc_alta=0;

int8

valor_adc_baja=0;

set_tris_b(0xF0);
output_b(0x00);
set_tris_c(0b00111000);

setup_adc_ports(AN0_TO_AN2);
setup_adc(ADC_CLOCK_DIV_64);
config_ADCON2();

LED_OFF(PWM1);
LED_OFF(PWM2);
usb_init();

usb_task();
USB_debug();

while (TRUE)
{

if(usb_enumerated())
{

valorPWM1_H=valorPWM1;
valorPWM1_L=255-valorPWM1_H;
for(valorPWM1_H;valorPWM1_H>0;valorPWM1_H--){
LED_ON(PWM1);}
for(valorPWM1_L;valorPWM1_L>0;valorPWM1_L--){
LED_OFF(PWM1);
}

valorPWM2_H=valorPWM2;
valorPWM2_L=255-valorPWM2_H;
for(valorPWM2_H;valorPWM2_H>0;valorPWM2_H--){
LED_ON(PWM2);}
for(valorPWM2_L;valorPWM2_L>0;valorPWM2_L--){
LED_OFF(PWM2);
}

if(input_state(SW1)==0x01){delay_ms(20); envia[0]=0x01;}else{envia[0]=0x00;}
if(input_state(SW2)==0x01){delay_ms(20); envia[1]=0x01;}else{envia[1]=0x00;}
if(input_state(SW3)==0x01){delay_ms(20); envia[2]=0x01;}else{envia[2]=0x00;}
if(input_state(SW4)==0x01){delay_ms(20); envia[3]=0x01;}else{envia[3]=0x00;}

set_adc_channel(0);
delay_us(10);
valor_adc_alta = (read_adc()>>8);
valor_adc_baja = (int)(read_adc());
envia[4]=valor_adc_alta;
envia[5]=valor_adc_baja;

set_adc_channel(2);
delay_us(10);
valor_adc_alta = (read_adc()>>8);
valor_adc_baja = (int)(read_adc());
envia[6]=valor_adc_alta;
envia[7]=valor_adc_baja;

usb_put_packet(1, envia, USB_CONFIG_HID_TX_SIZE, USB_DTS_TOGGLE);

if (usb_kbhit(1))
{
usb_get_packet(1, recibe, USB_CONFIG_HID_RX_SIZE);

if(recibe[0]==ACTIVA_SALIDAS){

switch(recibe[1]){
case LED_1:
output_toggle(PIN_B0);
break;
case LED_2:
output_toggle(PIN_B1);
break;
case LED_3:
output_toggle(PIN_B2);
break;
case LED_4:
output_toggle(PIN_B3);
break;
}
}
if(recibe[0]==PWM_CONTROL1)

{valorPWM1=recibe[2];}

if(recibe[0]==PWM_CONTROL2)
{valorPWM2=recibe[3];}

}
}
}
}
#define SW1

PIN_B4

#define SW2

PIN_B5

#define SW3

PIN_B6

#define SW4

PIN_B7

#define LED_GREEN PIN_C6

#define LED_RED

PIN_C7

#define PWM1

PIN_C2

#define PWM2

PIN_C1

#define USB_CONFIG_HID_TX_SIZE 32
#define USB_CONFIG_HID_RX_SIZE 32

#define ACTIVA_SALIDAS

0x0A

#define PWM_CONTROL1

0x0B

#define PWM_CONTROL2

0x0C

#define LED_1

0x10

#define LED_2

0x20

#define LED_3

0x30

#define LED_4

0x40

#define LED_ON output_high

#define LED_OFF output_low

void USB_debug();

void config_adcon2(void);
#IFNDEF __USB_DESCRIPTORS__
#DEFINE __USB_DESCRIPTORS__

#ifndef USB_CONFIG_PID
#define USB_CONFIG_PID 0x07D0
#endif

#ifndef USB_CONFIG_VID
#define USB_CONFIG_VID 0x1781
#endif

#ifndef USB_CONFIG_BUS_POWER
#define USB_CONFIG_BUS_POWER 100
#endif

#ifndef USB_CONFIG_VERSION

#define USB_CONFIG_VERSION 0x0100

#endif

#ifndef USB_CONFIG_HID_TX_SIZE
#define USB_CONFIG_HID_TX_SIZE 32
#endif

#ifndef USB_CONFIG_HID_RX_SIZE
#define USB_CONFIG_HID_RX_SIZE 32
#endif

#ifndef USB_CONFIG_HID_TX_POLL
#define USB_CONFIG_HID_TX_POLL 10
#endif

#ifndef USB_CONFIG_HID_RX_POLL
#define USB_CONFIG_HID_RX_POLL 10
#endif

#ifdef USB_HID_DEVICE
#undef USB_HID_DEVICE
#endif

#DEFINE USB_HID_DEVICE TRUE

#ifdef USB_EP1_TX_ENABLE
#undef USB_EP1_TX_ENABLE
#endif
#define USB_EP1_TX_ENABLE USB_ENABLE_INTERRUPT

#ifndef USB_EP1_TX_SIZE
#if (USB_CONFIG_HID_TX_SIZE >= 64)
#define USB_EP1_TX_SIZE

64

#else
#define USB_EP1_TX_SIZE

(USB_CONFIG_HID_TX_SIZE+1)

#endif
#endif

#ifdef USB_EP1_RX_ENABLE
#undef USB_EP1_RX_ENABLE
#endif
#define USB_EP1_RX_ENABLE USB_ENABLE_INTERRUPT

#ifndef USB_EP1_RX_SIZE

#if (USB_CONFIG_HID_RX_SIZE >= 64)

#define USB_EP1_RX_SIZE

64

#else
#define USB_EP1_RX_SIZE

(USB_CONFIG_HID_RX_SIZE+1)

#endif
#endif

#include <usb.h>

const char USB_CLASS_SPECIFIC_DESC[] =

{
6, 0, 255,
9, 1,
0xa1, 1,
0x19, 1,
0x29, 8,

0x15, 0x80,
0x25, 0x7F,

0x75, 8,
0x95, USB_CONFIG_HID_TX_SIZE,
0x81, 2,
0x19, 1,
0x29, 8,
0x75, 8,
0x95, USB_CONFIG_HID_RX_SIZE,
0x91, 2,
0xc0
};
const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP[USB_NUM_CONFIGURATIONS][1] =
{
0
};

const int16 USB_CLASS_SPECIFIC_DESC_LOOKUP_SIZE[USB_NUM_CONFIGURATIONS][1] =

{

32
};

#DEFINE USB_TOTAL_CONFIG_LEN

const char USB_CONFIG_DESC[] = {

USB_DESC_CONFIG_LEN,
USB_DESC_CONFIG_TYPE,
USB_TOTAL_CONFIG_LEN,0,
1,
0x01,
0x00,
#if USB_CONFIG_BUS_POWER
0x80,
#else
0xC0,
#endif
USB_CONFIG_BUS_POWER/2,

USB_DESC_INTERFACE_LEN,
USB_DESC_INTERFACE_TYPE,
0x00,
0x00,
2,
0x03,
0x00,
0x00,

41

0x00,

USB_DESC_CLASS_LEN,
USB_DESC_CLASS_TYPE,
0x00,0x01,
0x00,
0x01,
0x22,
USB_CLASS_SPECIFIC_DESC_LOOKUP_SIZE[0][0], 0x00,

USB_DESC_ENDPOINT_LEN,
USB_DESC_ENDPOINT_TYPE,
0x81,
USB_EP1_TX_ENABLE,
USB_EP1_TX_SIZE,0x00,
USB_CONFIG_HID_TX_POLL,

USB_DESC_ENDPOINT_LEN,
USB_DESC_ENDPOINT_TYPE,
0x01,
USB_EP1_RX_ENABLE,
USB_EP1_RX_SIZE,0x00,
USB_CONFIG_HID_RX_POLL
};

#define USB_NUM_HID_INTERFACES 1
#define USB_MAX_NUM_INTERFACES 1
const char USB_NUM_INTERFACES[USB_NUM_CONFIGURATIONS]={1};
const int16 USB_CLASS_DESCRIPTORS[USB_NUM_CONFIGURATIONS][1][1]=

{
18
};

#if (sizeof(USB_CONFIG_DESC) != USB_TOTAL_CONFIG_LEN)

#error USB_TOTAL_CONFIG_LEN not defined correctly
#endif

const char USB_DEVICE_DESC[USB_DESC_DEVICE_LEN] ={

USB_DESC_DEVICE_LEN,
0x01,
0x10,0x01,
0x00,
0x00,
0x00,
USB_MAX_EP0_PACKET_LENGTH,
USB_CONFIG_VID & 0xFF, ((USB_CONFIG_VID >> 8) & 0xFF),
USB_CONFIG_PID & 0xFF, ((USB_CONFIG_PID >> 8) & 0xFF),
USB_CONFIG_VERSION & 0xFF, ((USB_CONFIG_VERSION >> 8) & 0xFF),
0x01,
0x02,
0x00,
USB_NUM_CONFIGURATIONS
};

char USB_STRING_DESC_OFFSET[]={0,4,12};
char const USB_STRING_DESC[]={

4,
USB_DESC_STRING_TYPE,
0x09,0x04,
8,
USB_DESC_STRING_TYPE,

'C',0,
'C',0,
'S',0,

32,
USB_DESC_STRING_TYPE,
'J',0,
'E',0,
'T',0,
'S',0,
'-',0,
'U',0,
'S',0,
'B',0,
'-',0,
'U',0,

'E',0,
'P',0,
'S',0,
'A',0
};

#ENDIF

Conclusiones.- con la realizacin del proyecto pudimos demostrar la

correcta comunicacin entre entre un dispositivo usb elaborado por los
estudiantes y la computadora, proveyendo asi soluciones mas sencillas i
econmicas a mayores escalas.