MICROCONTROLADORES: marzo 2019

jueves, 28 de marzo de 2019

Laboratorio N° 04

MICROCONTROLADORES

Laboratorio N° 04

JUEGO DE TIRO A CANASTA CON
INDICAR DE PUNTOS

1. CAPACIDAD TERMINA
* Utilizar al microcontrolador en aplicaciones de control electrónico.
* Desarrollar y ejecutar programas en un microcontrolador PIC.
* Programar y configurar interfaces básicas del microcontrolador.

2. COMPETENCIA ESPECIFICA DE LA SESIÓN
* Conocer el uso de las subrutinas.
* Conocer las técnicas de elaboración de programas a través de algoritmos.
* Programación de un proyecto real.

2. MARCO TEORICO
Pseudocódigo

El pseudocódigo (o falso lenguaje) es comúnmente utilizado por los programadores para omitir secciones de código o para dar una explicación del paradigma que tomó el mismo programador para hacer sus códigos, esto quiere decir que el pseudocódigo no es programable sino facilita la programación.
El principal objetivo del pseudocódigo es el de representar la solución a un algoritmo de la forma más detallada posible, y a su vez lo más parecida posible al lenguaje que posteriormente se utilizará para la codificación del mismo.

El pseudocódigo utiliza para representar las acciones sucesivas palabras reservadas en inglés (similares a sus homónimos en los lenguajes de programación), tales como star,begin, end, stop, if-then-else, while, repeat-until….etc

Es un lenguaje de especificación de algoritmos. El uso de tal lenguaje hace el paso de codificación final (esto es, la traducción a un lenguaje de programación) relativamente fácil.
El pseudocódigo nació como un lenguaje similar al inglés y era un medio representar básicamente las estructuras de control de programación estructurada. Se considera un primer borrador, dado que el pseudocódigo tiene que traducirse posteriormente a un lenguaje de programación. Cabe señalar que el pseudocódigo no puede ser ejecutado por una computadora.

3. EVIDENCIAS
a) Programación

#include <16f877a.h> // Incluimos archivo con PIC a utilizar

#use delay (clock=20M) // Indicamos que trabajaremos a 20Mhz

#fuses HS, NOPROTECT, NOWDT // Configuración básica de los fusibles

int variable = 0;

int tabBCD[10]={0b00111111,0b00000110,0b01011011,0b01001111,0b01100110,

0b01101101,0b01111101,0b00000111,0b01111111,0b01101111};

int delay=5; // Completar con valor de retardo adecuado en ms

int16 dato=0; // Declaramos una variable ENTERA de 16 bits

int16 unidades=0, decenas=0, centenas=0;

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

// Funcion que descompone un número Entero de 4 cifras

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

void descomp_entero(int16 valor)

{

centenas = (int16) valor / 100; // 1er Dígito o Centenas

valor -= centenas * 100; // y se lo resto al valor

decenas = (int16) valor / 10; // 2do Dígito o Decenas

valor -= decenas * 10; // y también se lo resto

unidades = (int16) valor; // y por último solo me quedan las unidades

}

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

// Funcion para displayar en forma multiplexada

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

void visualizar(void)

{

output_b(tabBCD[centenas]);

output_a(0b00001000);

delay_ms(delay);

output_b(tabBCD[decenas]);

output_a(0b00000100);

delay_ms(delay);

output_b(tabBCD[unidades]);

output_a(0b00000010);

delay_ms(delay);

}

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

// Funcion para emitir un pitido

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

void BIP()

{

FOR (int i= 0;i<=100;++i)

{

output_high(PIN_E1); // Pone a "1" el pin E1 (envía 5 voltios)

delay_ms(1); // "Congela el tiempo" durante 1ms

output_low(PIN_E1); // Pone a "0" el pin E1

delay_ms(01); // "Congela el tiempo" durante 1ms

}

void SUM()

{

FOR (int a= 0;a<=100;++a)

{

output_high(PIN_A1); // Pone a "1" el pin E1 (envía 5 voltios)

delay_ms(1); // "Congela el tiempo" durante 1ms

output_low(PIN_A1); // Pone a "0" el pin E1

delay_ms(01); // "Congela el tiempo" durante 1ms

}

FOR (int s= 0;s<=100;++s)

{

output_high(PIN_A2); // Pone a "1" el pin E1 (envía 5 voltios)

delay_ms(1); // "Congela el tiempo" durante 1ms

output_low(PIN_A2); // Pone a "0" el pin E1

delay_ms(01); // "Congela el tiempo" durante 1ms

}

FOR (int d= 0;d<=100;++d)

{

output_high(PIN_A3); // Pone a "1" el pin E1 (envía 5 voltios)

delay_ms(1); // "Congela el tiempo" durante 1ms

output_low(PIN_A3); // Pone a "0" el pin E1

delay_ms(01); // "Congela el tiempo" durante 1ms

}

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

// FUNCION PRINCIPAL VOID (MAIN)

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

void main ()

{

dato = 000; // ingrese numero inicial a visualizar

descomp_entero(dato);

visualizar(); // mostramos el valor de "dato" en displays

while(1)

{

IF (!input(PIN_D0)) // SI INGRESA MONEDA

{

BIP();

delay_ms(500);

BIP();

delay_ms(500);

}

visualizar(); // mostramos el valor de "dato" en displays

IF (!input(PIN_D1) && (variable == 0)) // si ENCESTA CANASTA

{

dato = dato + 7;

descomp_entero(dato);

BIP();

delay_ms(500);

output_high(PIN_C0);

variable = 1;

}

visualizar();

IF (!input(PIN_D1) && (variable == 1)) // si ENCESTA CANASTA

{

dato = dato + 7;

descomp_entero(dato);

BIP();

delay_ms(500);

output_high(PIN_C1);

variable = 2;

}

visualizar();

IF (!input(PIN_D1) && (variable == 2)) // si ENCESTA CANASTA

{

dato = dato + 7;

descomp_entero(dato);

BIP();

delay_ms(500);

output_high(PIN_C2);

variable = 3;

}

visualizar();

IF (!input(PIN_D1) && (variable == 3)) // si ENCESTA CANASTA

{

dato = dato + 7;

descomp_entero(dato);

BIP();

delay_ms(500);

output_high(PIN_C3);

variable = 4;

}

visualizar();

IF (!input(PIN_D1) && (variable == 4)) // si ENCESTA CANASTA

{

dato = dato + 7;

descomp_entero(dato);

BIP();

delay_ms(500);

output_high(PIN_C4);

variable = 0;

visualizar();

IF (!input(PIN_D1) && dato == 35)

{

BIP();

delay_ms(100);

SUM();

delay_ms(100);

BIP();

delay_ms(100);

SUM();

delay_ms(100);

BIP();

delay_ms(100);

SUM();

delay_ms(100);

dato = 000;

visualizar();

}

visualizar();

}

4. OBSERVACIONES
* Al momento de realizar la programación, se tuvo que recurrir a teoría de clases anteriores para poder lograr la tarea dejada en laboratorio.
* Cuando se quiso realizar las pruebas correspondientes, la computadora no reconocia el entrenador, el cual retraso las pruebas.
* Al ver que no se podia trabajar con el entrenador se opto por usa el software de simuilacion "PROTEUS".

5. CONCLUCIONES
* Se logro realizar la programación con métodos usados en clases anteriores.
* concluyo de que el uso del entrenador no están indispensable, pero si facilita mejor su simulación y su trabajo.

6. INTEGRANTES
* Aldude Aldudi, Rosmel

Laboratorio N° 03

MICROCONTROLADORES

Laboratorio N° 03

PROGRAMACIÓN CON DISPLAY DE 7 SEGMENTOS

1. CAPACIDAD TERMINAL
* Utilizar al microcontrolador en aplicaciones de control electrónico.
* Desarrollar y ejecutar programas en un microcontrolador PIC.
* Programar y configurar interfaces básicas del microcontrolador.

2. COMPETENCIA ESPECIFICA DE LA SESIÓN
* Conocer el display de 7 segmentos y su funcionamiento.
* Conocer las tecnicas de multiplexación.
* Programar HMI para luego encestar.

3. MARCO TEÓRICO

Tipos de datos

Cualquier programa opera con los los datos. Dependiendo de su función, éstos pueden ser de varios tipos. Por ejemplo, para acceder a los elementos de un array se utilizan los datos del tipo de números enteros. Los datos de precios tienen el tipo de doble precisión en punto flotante. Esto se debe a que en el lenguaje MQL5 no está previsto ningún tipo especial para los datos de precios.

Los datos de diferentes tipos se procesan a diferentes velocidades. El procesamiento de datos de números enteros se realiza más rápido. Para procesar datos de doble precisión se utiliza un coprocesador especial. No obstante, a causa de la complejidad de demostración interna de los datos de punto flotante, éstos requieren más tiempo para ser procesados que los de números enteros.

Los que más lentamente se procesan son los datos en cadena de caracteres. Esto está relacionado con la distribución y redistribución dinámica de la memoria operativa del ordenador.

Principales tipos de datos:

· enteros (enteros (char, short, int, long, uchar, ushort, uint, ulong)

char

El tipo entero char ocupa en la memoria 1 byte (8 bits) y permite representar en el sistema numérico binario 2^8 valores = 256. El tipo char puede contener los valores positivos, igual que negativos. El rango de valores es de -128 a 127.

uchar

El tipo entero uchar también ocupa en la memoria 1 byte, igual que el tipo char, pero a diferencia de él, uchar está destinado únicamente para los valores positivos. El valor mínimo es igual a cero, el valor máximo es igual a 255. La primera letra u del nombre uchar es la abreviatura de la palabra unsigned (sin signo).

short

El tipo entero short tiene el tamaño de 2 bytes (16 bits), permite representar la multitud de valores igual a 2 elevado a 16: 2^16 = 65 536. Puesto que el tipo short es con signos y contiene los valores tanto positivos, como negativos, el rango de valores se oscila entre -32 768 y 32 767.

ushort

El tipo ushort es el tipo short sin signos, también tiene el tamaño de 2 bytes. El valor mínimo es igual a cero, el valor máximo es igual a 65 535.

int

El tipo entero int tiene el tamaño de 4 bytes (32 bits). El valor mínimo es de —2 147 483 648, el valor máximo es de 2 147 483 647.

uint

El tipo entero sin signos uint ocupa en la memoria 4 bytes y permite representar los valores de números enteros de 0 a 4 294 967 295.

long

El tipo entero long tiene el tamaño de 8 bytes (64 bits). El valor mínimo es de —9 223 372 036 854 775 808, el valor máximo es de 9 223 372 036 854 775 807.

ulong

El tipo entero ulong también ocupa 8 bytes y permite almacenar valores de 0 a 18 446 744 073 709 551 615.

· lógicos (bool)

Tipo bool

El tipo bool sirve para almacenar los valores lógicos true (verdadero) o false(falso) la representacion de los cuales es 1 o 0 respectivamente.

· literales (char, uchar)

· cadenas de caracteres (string)

Tipo string

Tipo string sirve para guardar las cadenas de caracteres. Una cadena de caracteres es una sucesión de caracteres en formato Unicode con el cero al final. A una variable string se le puede asignar una constante literal. Una constante literal es una sucesión de caracteres Unicode encerada entre comillas dobles: "Es una constante literal".

Para poder introducir una comilla doble (") dentro de la cadena hay que interponerle el signo de barra inversa (\). Cualquier constantede signo especial, si le interviene el signo de barra inversa (\), puede ser introducida en la cadena.

· de punto flotante (double, float)

Tipos reales (double, float)

Los tipos reales (o tipos de punto flotante) representan valores que contienen la parte fraccionaria. En el lenguaje MQL5 existen dos tipos para los números con punto flotante. El modo de representar los números reales en la memoria del ordenador se rige por el estándar IEEE 754 y no depende de las plataformas, sistemas operativos y lenguajes de programación.

· color (color)

Tipo color

El tipo color sirve para almacenar la información sobre el color y ocupa en la memoria 4 bytes. El primer byte no se cuenta, los demás 3 bytes contienen los componentes RGB.

Las constantes de colores pueden ser representadas de tres formas distintas: de forma literal, con números enteros o mediante un nombre (sólo para los colores-web concretos).

· fecha y tiempo (datetime)

Tipo datetime

El tipo datetime sirve para almacenar la fecha y la hora en forma de cantidad de segundos que han pasado desde el 1 de enero de 1970. Ocupa en la memoria 8 bytes.

Las constantes de fecha y hora pueden estar representadas por una línea de caracteres compuesta de 6 partes que representan el valor numérico del año, mes, día (o día, mes, año), hora, minuto y segundo. La constante se mete entre comillas simples y se empieza con el signo D.

El rango de valores es desde el 1 de enero de 1970 hasta el 31 de diciembre de 3000. Se puede omitir o la fecha (año, mes, día) o la hora (hora, minuto, segundo), o pueden ser las dos cosas.

Durante la especificación literal de la fecha, es deseable indicar el año, el mes y el día. Si no, el compilador mostrará un aviso sobre la entrada literal no completa.

· enumeraciones (enum)

4. EVIDENCIA

https://youtu.be/17RYbdngByk

5. OBSERVACIONES
* Al momento de realizar la programación, tener en cuenta el archivo del PIC a utilizar.
* Cuando se quiso realizar la descarga al PIC C COMPILER se tuvo problemas, ya que la maquina virtual no reconocía al entrenador.

6. CONCLUSIONES
* Se conoció el funcionamiento de Display de 7 segmentos y su previo funcionamiento.
* Se logro realizar la programación dejada en clase.
* se entendió algunos comandos usados en la programación.
* Se logro entender sobre como funciona la descomposición de un numero.
7. INTEGRANTE
* Aldude Aldudi, Rosmel

jueves, 14 de marzo de 2019

Laboratorio N° 01

MICROCONTROLADORES

Laboratorio N° 01

HERRAMIENTAS DE PROGRAMACIÓN HADWARE Y SOFTWARE

1. CAPACIDAD TERMINAL

* Utilizar al microcontrolador en aplicaciones de control electrónico.

* Desarrollar y ejecutar programas en un microcontrolador PIC

* Programar y configurar interfaces básicas del microcontrolador.

2. COMPETENCIA ESPECÍFICA DE LA SESIÓN

* Listar las partes internas generales de un microcontrolador.

* Identificar las funciones generales de un microcontrolador.

* Introducción a la programación en PIC C Compiler.

* Cómo utilizar el Entrenador.

3. MARCO TEÓRICO

Se denomina microcontrolador a un dispositivo programable capaz de realizar diferentes actividades que requieran del procesamiento de datos digitales y del control y comunicación digital de diferentes dispositivos. ... Este microcontrolador es fabricado por MicroChip familia a la cual se le denomina PIC.
Un microcontrolador es un circuito integrado que en su interior contiene:
- Una unidad central de procesamiento (CPU).
- Unidades de memoria (RAM y ROM)
- Puertos de entrada y salida y periféricos.
Estas partes están interconectadas dentro del microcontrolador, y en conjunto forman lo que se le conoce como microcomputadora.

El PIC 16F877.a es un microcontrolador de Microchip Technology fabricado en tecnología CMOS, su consumo de potencia es muy bajo y además es completamente estático (esto quiere decir que el reloj puede detenerse y los datos de la memoria no se pierden).

4. EVIDENCIAS

5. OBSERVACIONES
-Al momento de abrir el software para realizar la programación se tuvo que ingresar a la maquina virtual.
- Al realizar la primera prueba, se vio que los switch del lado derecho energizaban cada uno de los puertos, y de esa forma recién funcionaba el programa guardado en el microcontrolador .
- El PIC 16F877.a trabajado en el entrenador era un PIC de 40 pines.

6. CONCLUSIONES
- Se reconocio las partes internas que componen un microcontrolador.
- Se aprendió a ultilizar de una forma básica el entrenador.
- se logró utilizar adecuadamente los software de programacion a guardar en el entrenador.

INTEGRANTES
- Aldude Aldudi, Rosmel

Laboratorio N° 02

MICROCONTROLADORES

Laboratorio N° 02

PROGRAMACIÓN BÁSICA CON BUCLES DE CONTROL

2. COMPETENCIA ESPECIFICA DE LA SESIÓN
* Manejo de puertos de forma grupal e independiente para manejo de luces

* Programación de sonidos mediante subrutinas.

* Creación de Subrutinas mediante funciones.

* Declaración de variables enteras.

3. MARCO TEÓRICO

BUCLES DE CONTROL: while, if, if-else, for.

- Bucle Whileel bucle While se usa cuando se desea ejecutar un fragmento de codigo repetidamente hasta que la condicion "while" se evalua como falsa.Se puede definir como se muestra en el siguiente pseudo codigo.

while (/*condicion*/) {
 /* Código */
}

- Bucle "if-else"
En la gran mayoría de los programas será necesario tomar decisiones sobre qué acciones realizar. Esas decisiones pueden depender de los datos que introduzca el usuario, de si se ha producido algún error o de cualquier otra cosa.

La estructura condicional "if-else" es la que nos permite tomar ese tipo de decisiones. Traducida literalmente del inglés, se la podría llamar la estructura "si...si no", es decir, "si se cumple la condición, haz esto, y sino, haz esto otro".

if (condición) {
  sentencias_si_verdadero;
 } else {
  sentencias_si_falso;
 }

- Bucle "for"

El bucle for es un bucle muy flexible y a la vez muy potente ya que tiene varias formas interesantes de implementarlo, su forma más tradicional es la siguiente:

for (/* inicialización */; /* condición */; /* incremento */) {
 /* código a ejecutar */
}

Inicialización: en esta parte se inicia la variable que controla el bucle y es la primera sentencia que ejecuta el bucle. Sólo se ejecuta una vez ya que solo se necesita al principio del bucle.

Expresión condicional: al igual que en el bucle while", esta expresión determina si el bucle continuará ejecutándose o no.

Incremento: es una sentencia que ejecuta al final de cada iteración del bucle. Por lo general, se utiliza para incrementar la variable con que se inicio el ciclo. Luego de ejecutar el incremento, el bucle revisa nuevamente la condición, si es verdadera tiene lugar una ejecución más del cuerpo del ciclo, si es falsa se termina el ciclo y así.

4. EVIDENCIAS

- PROGRAMA REALIZADO

#include <16f877a.h>

#use delay (clock=20M)

#fuses HS, NOPROTECT, NOWDT

int salida=1;

int variable=0;

void main ()

{

output_c(0b00000000);

while (true)

{

IF (!input(PIN_A5) )

{

salida = salida << 1;

output_c(salida);

delay_ms(500);

}

IF (!input(PIN_D0) )

{

salida = salida >> 1;

output_c(salida);

delay_ms(500);

}

IF (!input(PIN_D1))

{

IF (variable == 0)

{

variable =1;

}

else

variable=0;

}

5. OBSERVACIONES

- En las pruebas realizadas se tuvo pequeñas dificultades con los bucles, debido a la falta de información.

- Cuando se realizo la tarea del laboratorio se tuvo que usar varias condicionales para que las condiciones se cumpla en el programa.

- Al momento de realizar la prueba, al presionar el botón A5 para iniciar el recorrido del encendido, no prendía en el led C0, si no el C1.

6. CONCLUCIONES

- Se logro utilizar el microcontrolador en aplicaciones de control electrónico.

- se desarrollo y ejecuto el programa realizado en el laboratorio funcionando de forma adecuada.

- Se logró programar y configurar la interface básica del microcontrolador

INTEGRANTE

- Aldude Aldudi, Rosmel