UNIVERSIDAD DE LAS FUERZAS ARMADAS

ESPE

Departamento de Eléctrica y Electrónica

MICROPROCESADORES

Integrantes:
- Christian Galarza
- Nicolás Jácome
- Christian Ruales
Docente: Ing. Miroslava Zapata
NRC: 2085
Fecha de entrega: 1 de diciembre de 2017

Sangolquí 2017
Tema

Uso del Visual Basic para enviar bits de información a una Unidad Aritmética Lógica
para que se muestre en un LCD el resultado.

Objetivos

- Desarrollar habilidades que permitan establecer una conexión entre el computador

y circuito integrado ALU mediante el uso del puerto paralelo.
- Incrementar el conocimiento relacionado a la programación en el lenguaje Visual
Basic, con el fin de poder manejar datos ingresados en una interfaz creada en dicho
lenguaje.

Marco Teórico

Arduino

El hardware consiste en una placa de circuito impreso con un microcontrolador,

usualmente Atmel AVR, puertos digitales y analógicos de entrada/salida,4 los cuales
pueden conectarse a placas de expansión (shields), que amplían los funcionamientos de
la placa Arduino. Asimismo, posee un puerto de conexión USB desde donde se puede
alimentar la placa y establecer comunicación con el computador.

Por otro lado, el software consiste en un entorno de desarrollo (IDE) basado en el entorno
de processing y lenguaje de programación basado en Wiring, así como en el cargador de
arranque (bootloader) que es ejecutado en la placa.4 El microcontrolador de la placa se
programa mediante un computador, usando una comunicación serie mediante un
convertidor de niveles RS-232 a TTL.

Los modelos de Arduino se categorizan en placas de desarrollo, placas de expansión

(shields), kits, accesorios e impresoras 3d.

 Placas: Arduino Galileo,16 Arduino Uno, Arduino Leonardo, Arduino Due,

Arduino Yún, Arduino Tre (En Desarrollo), Arduino Zero, Arduino Micro,
Arduino Esplora, Arduino Mega ADK, Arduino Ethernet, Arduino Mega 2560,
Arduino Robot, Arduino Mini, Arduino Nano, LilyPad Arduino Simple, LilyPad
Arduino SimpleSnap, LilyPad Arduino, LilyPad Arduino USB, Arduino Pro
Mini, Arduino Fio, Arduino Pro, Arduino MKR1000/Genuino MKR1000,
Arduino MICRO/Genuino MICRO, Arduino 101/Genuino 101, Arduino Gemma.
 Fig 1. Partes de Arduino Nano.

ALU (Unidad aritmética lógica)

Las ALU (Arithmetic Logic Unit), o unidades de lógica y aritmética, son dispositivos
muy versátiles que pueden programarse para llevar a cabo una gran variedad de
operaciones aritméticas y lógicas entre dos palabras binarias. En la figura 2 se muestra el
diagrama de pines de 74LS181, una ALU de 4 bits en tecnología TTL. Como se observa
de la figura, el positivo consta de dos grupo líneas de entrada A3, A2, A1, A0 y
B3,B2,B1,B0, un grupo líneas neas de salida F3,F2,F1,F0 ,un grupo de líneas selectoras
de función S3, S2, S1, S0 una línea selectora de modo M, una entrada de acarreo previo
Cn. una salida de acarreo resultante Cn+4, una salida de comparación A=B y dos salidas
de expansión P,G.

Programando adecuadamente las líneas de selección, S3, S2, S1, S0 y la de modo M junto
con la de acarreo previo, Cn , el circuito ALU puede ejecutar 16 operaciones lógicas y 32
operaciones aritméticas diferentes con los datos.

Fig 2. Distribución de pines 74LS181.

 Tabla 1. Funcionamiento 74LS181.

Cabe recalcar que en la Tabla 1 en las funciones que llevan el signo “+” se refiere a la
operación lógica OR, la suma se representa mediante “plus”.

Visual Basic

Es un lenguaje de programación dirigido por eventos, desarrollado por Alan Cooper para
Microsoft. Este lenguaje de programación es un dialecto de BASIC, con importantes
agregados. Su primera versión fue presentada en 1991, con la intención de simplificar la
programación utilizando un ambiente de desarrollo que facilitó en cierta medida la
programación misma.La última versión fue la 6, liberada en 1998, para la que Microsoft
extendió el soporte hasta marzo de 2008.

En 2001 Microsoft propuso abandonar el desarrollo basado en la API Win32 y pasar a un

framework o marco común de librerías, independiente de la versión del sistema operativo
.NET Framework, a través de Visual Basic .NET (y otros lenguajes como C Sharp (C#)
de fácil transición de código entre ellos); fue el sucesor de Visual Basic 6.
Aunque Visual Basic es de propósito general, también provee facilidades para el
desarrollo de aplicaciones de bases de datos usando Data Access Objects, Remote Data
Objects o ActiveX Data Objects.

Visual Basic contiene un entorno de desarrollo integrado o IDE que integra editor de
textos para edición del código fuente, un depurador, un compilador (y enlazador) y un
editor de interfaces gráficas o GUI.

Visual Basic dio un paso más en innovación y ahora es posible programar aplicaciones
Nativas para Android o IPhone utilizando un software de la compañía Anywhere
Software que transforma código Visual Basic (creado por dicha compañía) en APPs 100
% nativas en Java para ambos sistemas operativos de dispositivos móviles.1

Visual Basic está diseñado para crear productivamente aplicaciones seguras y orientadas
a objetos. Visual Basic permite a los desarrolladores segmentar Windows, Web y
dispositivos móviles. Al igual que con todos los lenguajes dirigidos a Microsoft .NET
Framework, los programas escritos en Visual Basic se benefician de la interoperabilidad
de seguridad y lenguaje.

Esta generación de Visual Basic continúa con la tradición de ofrecerle una forma rápida
y fácil de crear aplicaciones basadas en .NET Framework.

 Características

Los compiladores de Visual Basic generan código que requiere una o más librerías de
enlace dinámico para que funcione, conocidas comúnmente como DLL (sigla en inglés
de Dynamic-Link Library); en algunos casos reside en el archivo llamado
MSVBVMxy.DLL (siglas de "MicroSoft Visual Basic Virtual Machine x.y", donde x.y
es la versión) y en otros en VBRUNXXX.DLL ("Visual Basic Runtime X.XX"). Estas
bibliotecas DLL proveen las funciones básicas implementadas en el lenguaje,
conteniendo rutinas en código ejecutable que son cargadas bajo demanda en tiempo de
ejecución. Además de las esenciales, existe un gran número de bibliotecas del tipo DLL
con variedad de funciones, tales como las que facilitan el acceso a la mayoría de las
funciones del sistema operativo o las que proveen medios para la integración con otras
aplicaciones.

Dentro del mismo Entorno de desarrollo integrado (IDE) de Visual Basic se puede
ejecutar el programa que esté desarrollándose, es decir en modo intérprete (en realidad
pseudo-compila el programa muy rápidamente y luego lo ejecuta, simulando la función
de un intérprete puro). Desde ese entorno también se puede generar el archivo en código
ejecutable (exe); ese programa así generado en disco puede luego ser ejecutado sin
requerir del ambiente de programación (incluso en modo stand alone), aunque sí será
necesario que las librerías DLL requeridas por la aplicación desarrollada se encuentren
también instaladas en el sistema para posibilitar su ejecución.

El propio Visual Basic provee soporte para empaquetado y distribución; es decir, permite
generar un módulo instalador que contiene al programa ejecutable y las bibliotecas DLL
necesarias para su ejecución. Con ese módulo la aplicación desarrollada se distribuye y
puede ser instalada en cualquier equipo (que tenga un sistema operativo compatible).

Así como bibliotecas DLL, hay numerosas aplicaciones desarrolladas por terceros que
permiten disponer de variadas y múltiples funciones, incluso mejoras para el propio
Visual Basic; las hay también para el empaquetado y distribución, y hasta para otorgar
mayor funcionalidad al entorno de programación (IDE).

 Entorno de desarrollo
Existe un único entorno de desarrollo para Visual Basic, desarrollado por
Microsoft: Microsoft Visual Basic x.0, correspondientes a versiones desde la 2.0
hasta la 20.0, (con respectivas diferencias entre versiones del lenguaje).
El entorno de desarrollo es muy similar al de otros lenguajes. Realizando una
instalación típica del producto, las características básicas se presentan de la
siguiente forma:
 En la parte superior aparecen tres elementos, en este orden: la barra de título donde
figura el nombre del proyecto en curso y su estado (diseño o ejecución); la barra
de menú con 13 opciones desplegables y una barra de herramientas; esta última
se puede personalizar, posibilitando la inclusión de prácticamente la totalidad de
los comandos del IDE.
 En la parte central, cubriendo la franja de mayor área, se encuentra el espacio de
trabajo. Este incluye y muestra las ventanas del proyecto, las vistas del código
fuente de los módulos, los objetos y los controles que contienen las ventanas de
la aplicación y el panel de controles.
 El panel de controles, que aunque es móvil normalmente está ubicado a la derecha,
por defecto cuenta con los siguientes controles:
  PictureBox: Caja de imágenes
 Label: Etiqueta
 TextBox: Caja de texto
 Frame: Marco
 CommandButton: Botón de comando
 CheckBox: Casilla de verificación
 OptionButton: Botón de opción
 ComboBox: Lista desplegable
 ListBox: Lista
 HScrollBar: Barra de desplazamiento horizontal
 VScrollBar: Barra de desplazamiento vertical
 Timer: Temporizador
 DriveListBox: Lista de unidades de disco
 DirListBox: Lista de directorios
 FileListBox: Lista de archivos
 Shape: Figura
 Line: Línea
 Image: Imagen
 Data: Conexión a origen de datos
 OLE: Contenedor de documentos embebidos compatibles con Object Linking and
Embedding

Además de los listados, se pueden agregar todo tipo de controles de terceros, y hay una
gran cantidad de ellos que se proveen con el propio Visual Basic 6.0. Los controles vienen
embebidos dentro de archivos con extensión OCX.

Las ventanas de proyecto, aunque móviles, se encuentran en el panel lateral derecho y

contienen dos vistas principales:

El Explorador de proyectos, que muestra todos los elementos que componen el proyecto
o grupos de proyectos (formularios, interfaz de controles, módulos de código, módulos
de clase, etc.)
El Panel de propiedades, donde se muestran todos los atributos de los objetos, controles,
formularios, información de módulos clase, entre muchos otros.

La Ventana inmediato, por defecto se encuentra en la parte inferior, aunque puede no

estar visible (se presionan las teclas Ctrl+G, en ese caso, para mostrar la ventana). Esta
ventana resulta una herramienta muy útil a la hora de depurar el programa o bien para
realizar pruebas rápidas, ya que permite imprimir mensajes de texto desde el código y
ejecutar sentencias y comandos simples inmediatamente (solamente sentencias que se
puedan escribir en una sola línea). Por ejemplo, de la aplicación en curso, se puede
consultar el valor de una variable o llamar a un método declarado en el módulo que se
está depurando.

Justificación del circuito

El envío de información a la ALU se realiza por el programa Visual Basic y con un

complemento ActiveX llamado “hwinterface.ocx”. El código de programación es el
siguiente:

Dim suma
Dim A
Dim B
Private Sub Command0_Click()
A = &H0&
suma = A + B
Text2.Text = 0
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command1_Click()

A = &H1&
suma = A + B
Text2.Text = 1
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command10_Click()

A = &HA&
suma = A + B
Text2.Text = 10
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command11_Click()

A = &HB&
suma = A + B
Text2.Text = 11
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command12_Click()

A = &HC&
 suma = A + B
Text2.Text = 12
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command13_Click()

A = &HD&
suma = A + B
Text2.Text = 13
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command14_Click()

A = &HE&
suma = A + B
Text2.Text = 14
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command15_Click()

A = &HF&
suma = A + B
Text2.Text = 15
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command16_Click()

B = &HF0&
suma = A + B
Text3.Text = "15"
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command17_Click()

B = &HE0&
suma = A + B
Text3.Text = 14
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command18_Click()

B = &HD0&
suma = A + B
Text3.Text = 13
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command19_Click()

B = &HC0&
suma = A + B
Text3.Text = 12
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command2_Click()

A = &H2&
suma = A + B
Text2.Text = 2
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command20_Click()

B = &HB0&
suma = A + B
Text3.Text = 11
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command21_Click()

B = &HA0&
suma = A + B
Text3.Text = 10
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command22_Click()

B = &H90&
suma = A + B
Text3.Text = 9
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command23_Click()

B = &H80&
suma = A + B
Text3.Text = 8
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command24_Click()

B = &H70&
suma = A + B
Text3.Text = 7
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command25_Click()

B = &H60&
suma = A + B
Text3.Text = 6
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command26_Click()

B = &H50&
suma = A + B
Text3.Text = 5
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command27_Click()

B = &H40&
suma = A + B
Text3.Text = 4
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command28_Click()

B = &H30&
suma = A + B
Text3.Text = 3
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command29_Click()

B = &H20&
suma = A + B
Text3.Text = 2
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command3_Click()

A = &H3&
 suma = A + B
Text2.Text = 3
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command30_Click()

B = &H10&
suma = A + B
Text3.Text = 1
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command31_Click()

B = &H0&
suma = A + B
Text3.Text = 0
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command4_Click()

A = &H4&
suma = A + B
Text2.Text = 4
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command5_Click()

A = &H5&
suma = A + B
Text2.Text = 5
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command6_Click()

A = &H6&
suma = A + B
Text2.Text = 6
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command7_Click()

A = &H7&
suma = A + B
Text2.Text = 7
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command8_Click()

A = &H8&
suma = A + B
Text2.Text = 8
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Command9_Click()

A = &H9&
suma = A + B
Text2.Text = 9
Text1.Text = suma
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Form_Load()

A = &H0&
B = &H0&
suma = A + B
Text1.Text = suma
Text2.Text = A
 Text3.Text = B
Hwinterface1.OutPort &H378, suma
End Sub

Private Sub Text1_Change()

suma = A + B
Text1.Text = Hex(suma)
End Sub

Donde para cada botón pulsado se actualice inmediatamente la información en los Text.
La enviada de datos paralela al puerto serial se la realiza de la siguiente manera:

- Para el número A se asignan los 4 bits menos significativos del registro de datos
(desde D0 hasta D3).
- Para el número B se asignan los 4 bits restantes que serían los más significativos
del registro de datos (desde D4 hasta D7).
- El envío final de la información sería entonces la suma de ambos números, es
decir, si se desea un 6 en A y un 9 en B el proceso sería:
- Como se utiliza los 4 menos significativos en A se estaría asignando a esta
variable el valor de 01102 que en hexadecimal vendría a ser el 616 igualmente.
Para B de igual forma como se utiliza los 4 más significativos habría que enviar
la información 100100002 que sería el 9016 en hexadecimal. La suma de estos dos,
por lo tanto sería 100101102 o lo que se enviaría por el puerto el 9616.

La interfaz gráfica es la siguiente:

Fig 3. Interfaz gráfica.

Los datos viajan por el puerto paralelo y se conectan mediante cables a las entradas de la
Unidad Aritmética Lógica además de conectar la tierra para que sea común en el puerto
y en el protoboard. Se va a utilizar la configuración de entrada de datos en alto, por ende
hay que ingresar la información primero a unas compuertas negadoras para que de ahí se
conecte a la ALU.

Fig 4. Conexión Arduino-ALU

Como se observa en la imagen, los bits de A0-A3 y B0-B3 corresponderían a los del
registro de datos del puerto paralelo, desde D0 a D7, las entradas de S0-S3 que es el bus
de control de la ALU se opera manualmente con DIP switches.

Fig 5. Pines puerto paralelo.

De igual manera las salidas de la ALU van a mostrarse en un LCD de 16x2, existen 5 bits
de salida de la ALU que irían conectados a un medio para que se mostrase el resultado.
Por ende, para facilitar nos hemos propuesto a hacer la ilustración del resultado
empalmando el Arduino Nano con el LCD. Para eso se utilizó el siguiente código:
// El circuito:
// * LCD RS pin to digital pin 12
// * LCD Enable pin to digital pin 11
// * LCD D4 pin to digital pin 5
// * LCD D5 pin to digital pin 4
// * LCD D6 pin to digital pin 3
// * LCD D7 pin to digital pin 2
// * LCD R/W pin to ground
// * LCD VSS pin to ground
// * LCD VCC pin to 5V
// * 10K resistor:
// * ends to +5V and ground
// * wiper to LCD VO pin (pin 3)

// include the library code:

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
const int O0 = 6;
const int O1 = 7;
const int O2 = 8;
const int O3 = 9;
const int O4 = 10;

void setup()
{
Serial.begin (9600);
pinMode(O0, INPUT);
pinMode(O1, INPUT);
pinMode(O2, INPUT);
pinMode(O3, INPUT);
pinMode(O4, INPUT);
lcd.begin(16, 2);
lcd.setCursor(0, 1);
lcd.print("ESPE");
wd();
}

void loop()
{
lcd.setCursor(0, 1);
lcd.print("Bin - Num 4bits");
int acum = 0;
int o0 = 0;
int o1 = 0;
int o2 = 0;
int o3 = 0;
int o4 = 0;

if (digitalRead(O0) == HIGH)
{
o0 = 1;
Serial.print ("Alto O0 ");
}
else
{
o0 = 0;
Serial.print ("Bajo O0 ");
}
Serial.print (o0);
if (digitalRead(O1) == HIGH)
{
o1 = 2;
Serial.print ("Alto O1 ");
}
else
{
o1 = 0;
Serial.print ("Bajo O1 ");
}
 Serial.print (o1);
if (digitalRead(O2) == HIGH)
{
o2 = 4;
Serial.print ("Alto O2 ");
}
else
{
o2 = 0;
Serial.print ("Bajo O2 ");
}
Serial.print (o2);
if (digitalRead(O3) == HIGH)
{
o3 = 8;
Serial.print ("Alto O3 ");
}
else
{
o3 = 0;
Serial.print ("Bajo O3 ");
}
Serial.print (o3);
if (digitalRead(O4) == HIGH)
{
o4 = 16;
Serial.print ("Alto O4 ");
}
else
{
o4 = 0;
Serial.print ("Bajo O4 ");
}
Serial.print (o4);
lcd.setCursor(0, 0);
acum = o0 + o1 + o2 + o3 + o4;
lcd.print(acum);
Serial.print ("\n");
Serial.print (acum);
Serial.print ("\n");
delay(50);
lcd.clear();
}

void wd()
{
delay(1000);
lcd.clear();
}

Donde por cada bit de entrada, si está en alto un bit el resultado va a ser la suma de todos
estos bits, por ejemplo, si por una entrada específica está en alto en el acumulador iría la
suma de 2n donde n es el tamaño del bit en la palabra que en este caso es de 5 bits.
Conclusiones

- La conexión necesaria para enviar datos ingresados en una interfaz gráfica

desarrollada en Visual Basic a una ALU se ha realizado mediante el uso del puerto
paralelo de un computador, para la inicialización del LCD y el manejo de datos
de salida de la ALU se usó una placa Arduino Nano.
- Para el proceso de desarrollo del programa en el cual se ingresan los datos desde
el teclado del computador fue óptimo la utilización de botones en lugar de text
con el fin de que el dato se refresque cada que se presiona el botón que define el
número de entrada. La interfaz gráfica en este entorno de programación es
bastante intuitiva lo que no complicó su desarrollo.

Recomendaciones

- Asegurarse que el cable paralelo se ha soldado de manera correcta sino la

conexión no se realizará correctamente.
- El LCD se puede inicializar mediante un Arduino o una memoria la elección
queda a juicio del diseñador.
- Utilizar fuentes que alimenten correctamente el circuito en especial al LCD
Anexos