Laboratorio N°3

MICROCONTROLADORES

LABORATORIO N° 03

Programación con Display 
de 7 segmentos

Integrantes:

Chavez Cheneau David Alonso

Nina Trelles Cristofer

XI. CONTENIDO DEL INFORME EN EL BLOG:

1. Descripción de los TIPOS DE VARIABLES: entero, entero con signo, etc.

Variable : INT

Conociendo ya los tipos de variables básicas y cómo nombrarlas, veamos ahora cómo declararlas. La declaración de variables en C debe hacerse al principio del programa. Veremos ahora una forma básica que nos permita empezar a trabajar y, de paso, crear nuestro primer programa.
Usaremos para ello el tipo de variable int (entero). La sintaxis que usaremos será:

int [Nombre de variable];

Para facilitar la corrección y claridad de nuestros programas el lugar donde realizaremos la declaración de variables, al menos de momento, será después de la línea int main(), que constituye el inicio del código ejecutivo de nuestro programa. Crea un nuevo proyecto, denomínalo proyectoCurso2 y accede al código. Si no recuerdas cómo hacer esto, lee las explicaciones que hemos dado anteriormente. Una vez en la ventana de código, dentro del int main() {…} escribe:

int numeroDePlantas;

Has declarado la variable numeroDePlantas como tipo entero. También podrías asignarle un valor inicial a la variable en la misma línea que la declaras, de esta manera:

int numeroDePlantas = 15;

Este tipo de escritura nos permite declarar e inicializar la variable con un valor en una sola línea. No siempre lo haremos así, pero en algunas ocasiones nos puede resultar de interés. En otras ocasiones declararemos la variable en una línea y posteriormente le asignaremos contenido en otra.
Supón que declaras: int edad;, como variable destinada a contener la edad de una persona. Sabemos que la edad de una persona puede oscilar entre cero y 150 años (siendo groseros), y que sus valores no son decimales. Por tanto puede declararse como tipo int sin ningún problema. ¿Qué ocurriría si la declaráramos como tipo double?
a) Vamos a ocuparle (estimamos) 8 bytes al sistema cuando podríamos haber ocupado sólo 2. Es una falta de eficiencia y economía.
b) A la hora de liberar de errores al programa (depurarlo) no sabremos a ciencia cierta qué tipo de datos contiene la variable edad, ya que puede contener tanto el valor entero 56 como el valor decimal 56.332. Hacemos al programa más difícil de entender.
A la hora de declarar variables conviene seguir las pautas que ya hemos comentado y, resumidamente:
- Elegir siempre el tipo de variable más sencillo posible. Consideraremos que el grado de sencillez viene definido por la memoria requerida (a menor memoria requerida mayor es la sencillez). Esto redunda en un menor consumo de recursos del sistema y en una mayor rapidez de las operaciones que realiza el ordenador.
- Realizar declaraciones ordenadas y claras.
- Elegir un nombre descriptivo y claro, que comience preferiblemente con minúsculas.
En C podemosdeclarar variables en múltiples líneas una por línea pero también varias variables en una línea. Existen distintas formas para realizar declaraciones. Veamos ejemplos:

Expresión abreviada	Equivalente
a) int i, j, k;	a´) int i; int j; int k;
b) int i, j, k;	b´) int i; int j; int k;
c) int i=0, j=4, k=76;	c´) int i=0; int j=4; int k=76;
d) int i=0, j=4, k=76;	d´) int i=0; int j=4; int k=76;

 2. Video mostrando las TAREAS A SER EVALUADAS realizadas en laboratorio.

Observaciones:

-Observamos que para que el programa de pic compiler compile debemos de incluir el pic necesario de otra forma no compilara y saldrá error.

-Observamos que en el entrenador no funcionaba la salida A3 por esto debimos de cambiarla a la salida A0 que es de las centenas.

-Observamos que debemos de incluir en el programa todos los comandos necesarios para que estos se ejecuten de otra forma no funcionara.

-Observamos que el delay del bip es necesario que sea corto de otra forma podrian haber errores

Conclusiones:

-Utilizamos al microcontrolador en aplicaciones de control electrónico.

- Desarrollamos y ejecutamos programas en un microcontrolador PIC


- Programamos y configuramos interfaces básicas del microcontrolador.

LABORATORIO NRO. 2

PROGRAMACION BASICA CON BUCLES DE CONTROL
LAB 2 

Control de flujo I – if, if…else y for

El control de flujo permite variar, en un número ilimitado de ocasiones a lo largo de un programa, el orden “natural” de ejecución del código, omitiendo, ejecutando, o repitiendo sentencias o bloques de sentencias en función de una o varias condiciones. Las instrucciones para el control de flujo son comunes a muchos lenguajes de programación, y son if, if…else, for, while, y do…while. Además, veremos un par de sentencias capaces de variar el comportamiento de estas instrucciones: break y continue.

if

Realiza una comprobación de una condición. En el caso de que esta condición se cumpla, el código escrito entre llaves se ejecuta. Si, por el contrario, la condición entre paréntesis no se cumple, el código entre llaves es ignorado y el programa sigue ejecutándose normalmente.

Estructura básica de una sentencia if

Arduino

1 2 3

if (valorAComparar ?? valorDeReferencia) { instruccionesAEjecutar(); }

Como se puede apreciar en el código anterior, la comparación se realiza con el operador ??, que se ha de sustituir por cualquier operador lógico o cualquier operador de comparación. Hay que tener cuidado con el operador de comparación igual que (==), pues se suele confundir con el operador de asignaciónigual (=). Veámos algunos ejemplos:

Código que se ejecuta si x mayor que 0

Arduino

1 2 3 4 5 6 7

// Condición por la cual queremos que el código se ejecute // si una variable 'x' es mayor que cero if (x > 0) {   digitalWrite(ledPin, HIGH);   delay(1000);   digitalWrite(ledPin, LOW); }

Código que se ejecuta si x igual a 0

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// Condición por la cual queremos que el código se ejecute // si una variable 'x' es igual a cero // Sentendia mal construida. Lo que se está haciendo es igualar // una variable a cero en lugar de compararlas if (x = 0) {   digitalWrite(ledPin, HIGH);   delay(1000);   digitalWrite(ledPin, LOW); } // Sentencia bien construida if (x == 0) {   digitalWrite(ledPin, HIGH);   delay(1000);   digitalWrite(ledPin, LOW); }

Incluso podemos establecer más de una condición:

Ejecución de código si x mayor que 0 e y menor que 3

1 2 3 4 5 6 7 8

// Condición por la cual queremos que el código se ejecute // si una variable 'x' es mayor que cero, y además otra // variable 'y' es menor que 3. if (x > 0 && y < 3) {   digitalWrite(ledPin, HIGH);   delay(1000);   digitalWrite(ledPin, LOW); }

if…else

Complementa en cierto modo al control de flujo que ofrece la sentencia if, permitiendo ejecutar un bloque de código en el caso de que se cumpla la condición entre paréntesis, y otro bloque de código si la condición no se cumple. Estos dos bloques de código son mutuamente excluyentes, por lo que nunca se podrán ejecutar los dos a la vez.

Estructura de una sentencia if...else

1 2 3 4 5

if (valorAComparar ?? valorDeReferencia) { instruccionesSiCondicionSeCumple; } else { instruccionesSiCondicionNoSeCumple; }

Podemos anidar varias sentencias if…else, siendo todas ellas, a su vez, mutuamente excluyentes:

Anidación de sentencias if...else

1 2 3 4 5 6 7 8 9

if (x <= 0) { delay(100); } else if (x < 100) { delay(250); } else if (x <= 200) { delay(500); } else { delay(1000); }

Analicemos el código anterior, donde tenemos 4 sentencias mutuamente excluyentes que actuarán como control de flujo en función de distintas condiciones:

delay(100);  se ejecutará si:

•  x menor o igual que 0.

delay(250);  se ejecutará si:

• x mayor que 0, derivado de que la anterior condición no se ha cumplido.
• x menor que 100.

delay(500);  se ejecutará si:

• x mayor que 0 y  mayor o igual que 100, derivado de que las anteriores condiciones no se han cumplido.
• x menor o igual que 200.

delay(1000);  se ejecutará si:

• x mayor que 200, ya que ninguna de las anteriores condiciones se han cumplido.

for

Entramos en la parte del control de flujo relativa a la repetición de un bloque de código siempre que se cumpla una condición. Así pues, siempre que nos encontremos con una instrucción for -también llamado bucle for-, el código encerrado entre llaves se repetirá siempre que se cumpla la condición. Con cada repetición del bloque de código, la condición vuelve a ser evaluada.

Estrucutra típica de un bucle for

1 2 3

for (inicialización; condición; expresión) {   codigoAEjecutar(); }

Esta estructura está formada siempre por tres campos separados entre sí por un punto y coma. La inicialización se produce una sola vez y sirve para establecer un estado inicial a partir del cual empezar a evaluar la condición. La condición, como ya hemos dicho, se re-evalúa con cada repetición del bucle. Entonces, puede resultar obvio que siempre que se ejecute el bloque de código hay que variar alguna parte de la condición, evitando entrar en el denominado bucle infinito, donde un bloque de código se repite de forma infinita. Con tal fin, tenemos la expresión del tercer campo, una pieza de código que se va a ejecutar después de que lo haga el bloque de código encerrado entre llaves.

En el siguiente ejemplo vemos un caso muy simple pero práctico para imprimir por el puerto serie los números del 0 al 9:

Imprimir por el puerto serie los enteros de 0 a 9

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// Para imprimir por consola los números enteros del 0 al 9 // podemos ir por el camino clásico Serial.println(0); Serial.println(1); Serial.println(2); Serial.println(3); Serial.println(4); Serial.println(5); Serial.println(6); Serial.println(7); Serial.println(8); Serial.println(9); // Pero podemos agilizarlo con un bucle for for (int i = 0; i < 10; i++) { Serial.println(i); }

Pero aquí no acaba la cosa. De los 3 campos del bucle for, podemos obviar tantos como queramos, siempre y cuando incluyamos los puntos y coma. Así, podemos hacer la inicialización antes del bucle  (o no hacerla), evaluar la condición dentro del bucle, o modificar la condición dentro del bloque entre llaves.

Bucle for sin los tres campos

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

// Podemos obviar la inicialización int i = 0; for ( ; i < 10; i++) { Serial.println(i); } // Si quitamos la expresión y la inicialización int i = 0; for ( ; i < 10 ; ) { Serial.println(i); i = i + 1; } // Si quitamos los tres campos, tenemos un bonito bucle infinito. // Veremos en la segunda parte como arreglarlo int i = 0; for ( ; ; ) { if (i < 10) { Serial.println(i); } i = i + 1; }

Nos vemos en la segunda parte de la bilogía destinada al control de flujo, donde explicaremos conceptos tan interesantes como los bucles while y do…while, y las sentencias break y continue.

CAPTURAS DEL CURSO VIRTUAL 

Chavez Cheneau David Alonso

Nina Trelles Cristofer

Vídeo de Simulación en clase

Video de Tareas a ser evaluadas

Observaciones:

-Observamos que tenemos que cargar el programa a usar en el comando #include ya que a veces nos puede dar un error y no compilaría el código.

-Existen funcionen que obligatoriamente deben estar incluidas en nuestro comando por ejemplo la función void y la include o int ya que sin estas no estaríamos declarando o dándole la base al programa.

-Observamos que el comando while true se ejecuta para bucles de control ya que gracias a estar el programa puede volver a ejecutarse indefinidamente.

-Nos dimos cuenta de que podemos crear infinidades de programas para diferentes funciones en el ámbito de la electrónica y sus aplicaciones.

-Tuvimos que entender el primer programa para poder crear otro apartir de este ya que los comandos son la parte escensial de esto y deben ser utilizados específicamente.

Conclusiones:

-Utilizamos el microcontrolador en aplicaciones de control electronico.

-Desarrollamos y ejecutamos programas de un microcontrolador PIC.

-Programamos y configuramos interfaces basicas de un microcontrolador.

-Aprendimos a cargar los programas tanto en el entrenador como en la tarjeta real .

-Diferenciamos los dos archivos que nos proporciona el pic compiler cada uno para diferente plataforma.