Fuera del curso

Dejamos este capítulo para temas que ya son fuera del curso pero que puede servir al docente para explicar conceptos teóricos con el Arduino

Electrónica analógica

La electrónica es la ciencia que estudia y diseña dispositivos relacionados con el comportamiento de los electrones en la materia. En nuestro caso estudiaremos los componentes básicos utilizados en estos circuitos de bajo voltaje y usaremos Arduino, y la placa EduBásica, para practicar y entender mejor su funcionamiento.

Resistencias

Los componentes electrónicos llamados resistencias se utilizan en los circuitos para variar los valores de intensidad y voltaje. A veces tenemos que alimentar un dispositivo y sólo disponemos de una fuente de voltaje que puede dañarlo si se conecta directamente, como ocurre por ejemplo con los ledes. Al conectarlos directamente a un pin digital de Arduino (+5V), la corriente que circula es demasiado alta para el led y una exposición prolongada puede provocar que se queme. Para evitar esto conectamos en serie con el led una resistencia eléctrica (220 ohmios por ejemplo) que hace que el valor de la intensidad sea menor. El led lucirá algo menos que si lo conectamos directamente pero alargará su vida útil.

El valor de una resistencia se suele identificar mediante unas bandas de colores impresas en su superficie. La interpretación del código de colores la puedes obtener en  http://es.wikipedia.org/wiki/Resistor aunque suele ser recomendable, a la hora de realizar prácticas con circuitos electrónicos, utilizar un polímero que nos permitirá, entre otras cosas, medir la resistencia eléctrica en ohmios de estos componentes.

Divisor de tensión

Muchas veces necesitamos sacar una tensión que no es la máxima de la alimentación (en este caso 5V) el truco es hacerlo por resistencias, en forma de divisor de tensión:

Si aplicamos la ley de Ohm podemos deducir la siguiente fórmula: [aquí si quiere ver la demostración]

En este caso utilizaremos el divisor de tensión para demostrar que modificando la R2 por resistencias en serie o paralelo, se modifica la tensión Vout que el Arduino lo leerá y lo visualizará en un LED

Montaje 1: Resistencias en serie

Elige cuatro resistencias de cualquier valor para los montajes en serie pero procura que sean de valores muy distintos. Para ello utiliza la tabla con los códigos de colores o bien mide los valores directamente con un polímetro (medida de ohmios).

Con EDUBÁSICA

Monta el siguiente circuito divisor de tensión:

El cable rojo es la Vin (5V) y el negro GND. El cable azul es la salida Vout que la lee A2 por eso está conectado al A2 de EDUBASICA

Usa la protoboard para intercalar, entre los extremos del cable azul y negro, las resistencias que elegiste y prueba distintas combinaciones en serie quitando y poniendo resistencias. Debes observar que la luminosidad del led varía.

SIN EDUBÁSICA

Igual, simplemente que A2, Vin y GND lo tienes en el mismo ARDUINO

Continuamos...

El programa que hay que ejecutar en el arduino es este

//Conectaremos resistencias en serie entre Vout=A2 y GND

void setup() {                 
  // Pin 3 tiene el LED verde
  pinMode(3, OUTPUT);       
}
void loop() {
  analogWrite(3,analogRead(2)/4);
//Dividimos el valor entre 4 para adecuar la salida a 255
}

Reflexión

¿Cómo afecta el valor de las resistencias en serie en la luminosidad del LED?

Solución

Según la fórmula del divisor de tensión CUANTO MÁS RESISTENCIA HAYA ABAJO (R2 en la fórmula) MÁS TENSIÓN HAY por lo tanto más se ilumina el led que visualiza lo que entra por A2).

Montaje 2: Resistencias en paralelo.

Este ejercicio es similar al anterior, puedes usar las mismas resistencias y el mismo programa.

Une ahora uno de los extremos de las resistencias conectadas en paralelo al pin 2 analógico y el otro extremo a GND. Prueba a quitar alguna de las resistencias y obtén conclusiones de lo que ocurre.

CON EDUBASICA

SIN EDUBASICA

Diodos

Seguro que has oído hablar de los diodos LED (Light-Emitting Diode) pues están muy de moda. Un diodo led no es más que un diodo que emite luz cuando está polarizado correctamente.

Un diodo (del griego "dos caminos") es un dispositivo semiconductor que permite el paso de la corriente eléctrica en una única dirección con características similares a un interruptor.

De forma simplificada, la curva característica de un diodo (I-V) consta de dos regiones: por debajo de cierta diferencia de potencial, se comporta como un circuito abierto (no conduce), y por encima de ella se comporta como un cortocircuito con muy baja resistencia eléctrica.

Veamos si sabes como polarizar un diodo...

Un diodo se dice polarizado directamente cuando su cátodo está a un potencial inferior al ánodo. Los diodos por tanto deben especificar cual es el ánodo y el cátodo. En la foto puedes ver como un diodo led identifica su cátodo con una patilla recortada.
En otro tipo de diodos se puede identificar el cátodo gracias a una raya dibujada sobre el componente.

CURVA CARACTERÍSTICA DE UN DIODO:

Vamos a estudiar la curva I-V de un diodo de tal manera que comprobaremos que al aplicar un cierto voltaje el diodo conduce y no conduce (estado en corte) si estamos por debajo de ese voltaje o diferencia de potencial. En el caso específico de un diodo la diferencia de potencial a superar es de 0,7 V; si es un diodo LED es más del doble. A partir de ese valor conduce la corriente eléctrica y si es un LED, empieza a iluminarse.

Montaje 7 Estudio de la tensión umbral de un LED

Objetivo: Medir la tensión del diodo con Arduino con una entrada analógica, A0 (por ejemplo) para detectar la tensión umbral. El diodo lo alimentaremos con un potenciómetro para ir subiendo los valores

CON EDUBÁSICA

Vamos a realizar el siguiente esquema:

Para conectar un cable con A0 tenemos que localizar el orificio (señalado en esta imagen) y para la masa utilizamos el segundo tornillo

Montamos:


Carga este código en tu placa Arduino:

float val = 0;

void setup(){
    Serial.begin(9600);
}
void loop(){
    val = analogRead(A0);  //leemos el potenciómetro (0-1024)
    val = val/204,6; //mapeamos los valores para que sean de 0 a 5V
    Serial.print (val);  
    Serial.print ("V"); //vemos por pantalla el valor en Voltios
    Serial.println();
    delay(1000);
}

Abre el Monitor serial de Arduino (ctrl+may+M) y verás el voltaje que está ofreciendo Arduino al montaje que has hecho.

Mueve el potenciómetro y verás que el valor va cambiando. Intenta averiguar cual es la tensión umbral a partir de la cual tu led empieza a emitir luz.

Nota: inicialmente la corriente puede ser muy baja por lo que debes fijarte bien cuando empieza a iluminarse.

Verás que alrededor de 2.5V el led empieza a iluminarse

TRUCO

Se puede hacer sin ningún circuito exterior, utilizando la resistencia R5 y el diodo de VIN, para ello bastaría:

• Desconectar el interruptor que une V1 con Vin
• Unir con un cable V1 con A0

Poner interruptor en OFF y unir el cable uniendo V1 con A0 (dibujado en morado) :

SIN EDUBASICA

Igual, simplemente que tienes que hacer el circuito del potenciómetro exteriormente

Condensadores

Dos conductores cualesquiera separados por un aislante constituye un condensador. Este tipo de dispositivos eléctricos tienen gran variedad de usos como filtrar señales, eliminar ruido eléctrico o almacenar carga eléctrica entre otros.

En casi todas las aplicaciones prácticas cada conductor se encuentra inicialmente descargado y al conectarlos a una batería, mediante transferencia de carga de la batería a los conductores, van adquiriendo una cierta carga (dicho proceso se denomina carga del condensador). En todo momento, ambos conductores tienen igual carga pero de signo opuesto de tal forma que entre ambos conductores existe un campo eléctrico y por tanto una diferencia de potencial que se opone a la externa responsable de su carga. El proceso de carga del condensador se detiene cuando la diferencia de potencial entre los conductores del mismo se iguala a la de la batería. 

Hay que resaltar que aunque cada placa se encuentra cargada, la carga neta del condensador sigue siendo nula, puesto que la carga de cada conductor es igual a la del otro pero con signo contrario. Es por ello que cuando se dice que un conductor tiene una carga Q realmente lo que se está diciendo es que tiene una carga +Q en el conductor que se encuentra a mayor potencial y una carga – Q en el conductor a menor potencial (supuesto Q positiva).

Montaje 8: Carga de un condensador

El objetivo de esta práctica es visualizar la carga de un condensador aprovechando que Arduino puede leer los valores y podemos transmitirlo al ordenador por el puerto serie, usaremos el Arduino como una capturadora de datos y así de forma pedagógica enseñamos cómo es la carga.

SIN EDUBÁSICA

Hacemos una carga del condensador moviendo el cable rojo curvo desde masa a la alimentación. La unión entre resistencia y condensador lo conectamos a A5.

OJO: LA PATA (-) DEL CONDENSADOR TIENE QUE IR A GND (peligro de explosión si el condensador es electrolítico y si es muy grande)

El cable amarillo inicialmente lo conectamos a GND y luego procederemos a cargar el condensador soltandolo de GND y conectándolo a 5V

El cable rojo mide la tensión del condensador y lo mapearemos por A5 del Arduino.

CON EDUCASICA

(realmente la EDUBASICA en esta práctica no simplifica el cableado)

Continuamos ....

Y ejecutamos el siguiente código:

float sensorPin = A5;    
float sensorValue = 0;  

void setup() {

  Serial.begin(9600);  
}

void loop() {
  sensorValue = analogRead(sensorPin); 
  sensorValue = sensorValue/204.6;   //lo mapeamos a Voltios
  Serial.println(sensorValue);
  delay(100);  
}

Por el monitor serie se van visualizando los valores, ver el vídeo:

La ventaja de utilizar el Arduino, y no el polímetro, es que podemos copiar los valores y pegarlos en una hoja de cálculo, y así visualizar la curva de carga del condensador:

En este caso, se ha utilizado una resistencia de 100k y un condensador de 10uF por lo tanto el tiempo de carga es T= 5RC = 5 seg que es lo que aproximadamente refleja la gráfica. En tu kit de robótica para hacer este curso tienes unos valores parecidos.

Nota con los valores X: Como la instrucción delay se ha puesto el valor delay(100) por lo tanto hay 0.1segundo entre número y numero, por lo tanto los valores de la X tienen que ser 0, 0.1, 0.2, 0.3 ... en la hoja de cálculo, en la casilla A3 es = A2+0.1 y A1 tiene el valor inicial 0 segundos.

Nota con los valores Y: Si se pega los valores en una hoja de cálculo, no interpreta el caracter "." como una "," por lo que se aconseja utilizar una columna que convierta estos valores con la función en Excell, por ejemplo el valor en B2 puede ser : =VALOR(REEMPLAZAR(C2;2;1;",")) donde C es la columna donde se pegan los valores del monitor serie.

La hoja Excell que se ha utilizado te lo puedes descargar aquí

Montaje 9: Descarga del condensador

Si has hecho el montaje anterior, terminarás con el condensador totalmente cargado, procede con el mismo programa que va leyendo A5 a desconectar el cable amarillo de 5V y conectarlo a GND entonces el condensador se irá descargando a masa.

SIN EDUBASICA

CON EDUBÁSICA

Continuamos ...

Por el monitor serie se van leyendo los valores, puedes copiarlos y pegarlos en la misma hoja excell y verás la gráfica de descarga del condensador, que con el misma fórmula T=5RC nos sale aproximadamente 5 segundos de prácticamente el tiempo de descarga:

Transistores

Ciertos dispositivos tecnológicos necesitan una corriente eléctrica mayor que la que proporciona la placa EduBásica y para ello se utiliza el transistor.

El transistor es sin duda el componente electrónico más importante. Está formado por 3 capas de material semiconductor, cada una con un terminal metálico para poder conectarlo a los circuitos. Los materiales semiconductores se pueden comportar como aislantes o conductores según la energía que reciban, de ahí su versatilidad en el campo de la electrónica. Los 3 terminales de los transistores son:

Colector: Entrada de corriente.

Base: Entrada de corriente. Regula el funcionamiento.

Emisor: Salida de corriente.

Según la forma en la que conectemos los terminales del transistor a resistencias externas éste puede funcionar de 3 formas:

El funcionamiento típico en circuitos de señales ANALÓGICAS 

Como funcionamiento en zona “activa” : La resistencia conectada a la base del transistor tiene un valor que permite circular corriente a través de ella. De esta manera hay circulación de corriente entre el colector y emisor cuyo valor será proporcional a la corriente que circula por la base. Normalmente mucho mayor  con lo que producirá el efecto de amplificación. 

En resumen: El transistor actúa como un *amplificador de corriente  *

La ganancia de corriente β también llamado hfe, se calcula dividiendo la corriente de colector con la corriente de base,

Los funcionamientos típicos de circuitos DIGITALES

Como interruptor abierto o en “corte”: Si la corriente que circula por la base es nula, normalmente debido a que se conecta a ella una resistencia de un valor muy elevado, el transistor no permite el paso de corriente entre colector y emisor.

Como interruptor cerrado en zona de “saturación”: Si se va aumentando la intensidad que circula por la base llega un momento que la intensidad entre colector y emisor ya no aumenta más; es decir, se satura.

CONEXIONES

Vamos a definir las conexiones para los siguientes montajes del transistor, utilizaremos tenemos un TIP121 o TP120 es un transistor NPN tipo "Darlington" es decir, está integrado por dos transistores interiormente.

SIN EDUBASICA

Realizaremos el siguiente esquema,conectando la base al D6 y dejando el colector abierto para los experimentos:

por lo tanto:

CON EDUBASICA

En la shield ya tenemos el siguiente esquema:

Los conectores X2-2 y X2-1 son los de abajo a la izquierda. X2-2 es el colector del transistor y X2-1 es V1 (aunque en la foto pone Vin):

V1 y Vin está conectado por el interruptor según este esquema:

Luego es mejor que el interruptor esté conectado en ON para unir V1 con Vin y cortar el diodo D1, en caso contrario se nos va la corriente de la resistencia de colector por D1 a R5 y al led engañando la medida.

Vin son aproximadamente 5V de potencia de entrada al arduino que se utilizan si no lo alimentamos por el USB. 

Montaje 10: saturación y corte

Podemos jugar con el transistor en los estados saturación y corte, para ello vamos a crear una variable n que es un contador (en estado inicial n=1 y en los sucesivos se incrementa una unidad n++), si el contador es par ( el resto de n/2 = 0 o sea n%2==0) la intensidad de la corriente base sea 0 y en caso contrario que sea máxima. Pondremos un retardo de 3 segundos para visualizar bien los valores que medimos.

El programa sería:

int ledPin = 6;
int potenPin = A0;
int intensity, valor_poten;
int n;

void setup() {
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
n=1;
}

void loop() {
    if (n%2==0) intensity = 0;
    else intensity = 255;
    analogWrite(ledPin,intensity); //Envia una onda PWM especificado en la varible: intensity.
    Serial.print("n=");
    Serial.print(String(n));
    Serial.print("\tintensity = ");
    Serial.print(String(intensity));
    Serial.print("\n");
    n++;

    delay (3000);
}

El programa es un poco "tremendo" ¿hay alguna manera de simplificarlo?

CON EDUBASICA

Pondremos una resistencia de colector de 1k para forzar una corriente de saturación, pero como desde el conector X2-2 hasta V+ hay mucha distancia para conectar los dos extremos de la resistencia, utilizaremos la placa Protoboard:

Mediremos entre colector y masa, y vemos que alternativamente pasa de los estado corte (casi 5V) a saturación (casi 0V).

SIN EDUBASICA

RESULTADO

Si medimos la tensión en la base, vemos que pasa de 0V a 1.28V :

Montaje 11: zona activa

En esta práctica el transistor va a actuar como amplificador de corriente, dentro de la zona activa para ello se va a realizar el siguiente montaje:

SIN EDUBASICA

Ponemos una resistencia en el colector y un potenciómetro en A0:

CON EDUBASICA

Continuamos...

El funcionamiento de este circuito es el siguiente: a partir de potenciómetro que tenemos en la placa EduBásica controlamos la salida PWM del pin D6 variando la tensión aplicada a la resistencia de base Rb que en Edubásica es R6:

Y sin edubásica mediremos en la resistencia conectada en la base.

Utilizaremos el siguiente código:

int ledPin = 6;
int potenPin = A0;
int intensity, valor_poten;
int n;

void setup() {
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
n=1;
}

void loop() {
    valor_poten=analogRead(potenPin);
    intensity = map(valor_poten, 0, 1024, 0, 255);
    analogWrite(ledPin,intensity); 
    Serial.print("valor analógico leído=");
    Serial.println(analogRead(valor_poten));
    delay (1000);
}

El resultado es que podemos tener el transistor dentro de la zona activa manejando el potenciómetro, en el siguiente vídeo se muestra el polímetro que mide la tensión del colector y como varía de corte (casi 5V) a saturación (casi 0V) pasando por la zona activa: 

Montaje 12: Con un diodo se ve bien

Podemos insertar un diodo en el colector y se visualiza bien las zonas:

SIN EDUBASICA

CON EDUBASICA

Continuamos

El programa es el mismo que el anterior y se puede ver en el vídeo las tras formas de funcionamiento del transistor. Se trata de ir variando el valor del potenciómetro R1, con el fin de conseguir que el diodo led pase de estar apagado (corte), a encendido en diferentes grados de luminosidad, llegando finalmente hasta su máxima luminosidad (saturación).

La mayor o menor intensidad del diodo led nos indicará la mayor o menor corriente que fluye por el colector (IC) al variar la corriente de base (IB).

Resultados

Mediante un polímetro se pueden medir los valores de tensión. Para medir estas corrientes recurriremos, como en otras ocasiones, al polímetro en forma de voltímetro y aplicar la ley de Ohm.

A nosotros nos ha salido resultados (xlsx - 15,87 KB)

Montaje 13: cálculo de hfe

Con el mismo circuito anterior, se mide la tensión en los terminales de Rb (que está en la placa) y Rc (la que hay que montar en un protoboard) completando la siguiente tabla:

Se varía el potenciómetro, progresivamente para conseguir las tensiones en la resistencia de base que figuran en la tabla Una vez obtenidos todos los valores, calcular la Intensidad de colector y la intensidad de la base con estas fórmulas

que en el caso de Edubásica Rb es R6 y son 10k

Creemos que la mejor forma de leer Vrb es desde los extremos de la base del transistor y D6:

Podemos llevarlos a una gráfica y trazar la curva característica Ic= f(Ib)

La ganancia de corriente β se calcula: 

Según la DataSheet de este transistor te tiene que salir alrededor de 1.000, nosotros hemos realizado la práctica y nos sale 13 ¡no lo entendemos! :(

[resultados (xlsx - 15,87 KB)]

Recta de carga de un transistor

Se trata de comprobar de forma práctica el efecto de amplificación de corriente de un transistor, así como de determinar su punto de trabajo para un determinada corriente de base y la recta de carga. El circuito es el mismo que la práctica anterior.

La siguiente expresión se corresponde con la ecuación de la recta de carga: 

Para dibujar esta recta sobre la curva característica determinaremos primero sus extremos (IC = 0 y VCE = 0):

Te proponemos realizar los cálculos teóricos y dibujar la recta de carga en una gráfica Ic (eje y) y Vce (eje x) y sobre esta gráfica representar los puntos Ic Vce que has medido experimentalmente, utilizando las fórmulas

Te puede salir una cosa así:

Electrónica digital

Entendemos por electrónica digital, la que se encarga de sistemas electrónicos en los que sólo existen 2 valores o estados: verdadero/falso, "0" ó "1". 

En este capítulo trabajaremos los conceptos principales del Álgebra de Boole y de las puertas lógicas que utilizaremos para diseñar circuitos. Utilizaremos Arduino y la placa EduBásica.

Conocimiento previo

• Programación básica de Arduino.

Objetivos

• Conocer las propiedades del Álgebra de Boole.
• Operar con variables binarias.

Lista de materiales:

• Placa Arduino.

Álgebra de Boole

- Magnitudes analógicas: Tienen un número infinito de valores, por ejemplo, todas las magnitudes físicas como temperatura, velocidad, electricidad, tiempo, etc … - Magnitudes digitales: Consideraremos señales digitales binarias que son las que sólo toman dos valores discretos: el uno o el cero. Representarán estados “activados” o “desactivados” Por ejemplo una bombilla puede estar encendida  o apagada.

Para poder trabajar con datos binarios, el matemático inglés George Boole (1815-1864) creó una estructura algebraica que consta únicamente de 2 elementos (bits). Una álgebra que seguro conoces y utilizas a diario es el álgebra elemental, basado en la aritmética decimal que consta de 10 elementos (números), operaciones (suma, resta, ....) y propiedades (conmutativa...). Toda álgebra consta de esos 3 apartados: elementos, operaciones y propiedades. El álgebra de boole comprende:

• Elementos: 0 y 1. 
• Operaciones: multiplicación, suma, negación.
• Propiedades: conmutativa, asociativa, distributiva, elemento negado.

A los elementos de un circuito eléctrico se pueden asociar estados de “1” ó “0” si están encendidos o apagados y cerrados (conectados) o abiertos (desconectados) respectivamente.

Montaje 1 AND sin EDUBASICA

PULSADORES:

Vamos a simular dos entradas lógicas (“1” ó “0”) con dos pulsadores, (pueden ser conmutadores). En este ejemplo usaremos la función AND de manera que, según el estado de las 2 entradas, obtendremos una señal de salida (“1” ó “0”) conforme a la tabla de verdad de la operación. Si te animas puedes montar el circuito tú mismo en una protoboard siguiendo este esquema:

Las entradas están en los pines digitales 1 y 2. Y la salida del sistema es un led (en pin 5) que estará encendido/apagado según el resultado de aplicar la función AND a las 2 variables de entrada.

PROGRAMA:

```cpp / Boole Función AND con 2 variables /

int var1 = 7; //Pin de entrada del pulsador 1 int var2 = 2; //Pin de entrada del pulsador 1 int led = 5; //Pin de salida para el led(rojo) int estado1 = 0; //Para almacenar el estado de la variable1 int estado2 = 0; //Para almacenar el estado de la variable2 int resultado = 0; //Para almacenar el resultado

void setup() { pinMode(var1, INPUT); //Iniciliza el pin de entrada 1 como salida pinMode(var2, INPUT); //Iniciliza el pin de entrada 2 como salida
pinMode(led, OUTPUT); //Iniciliza el pin del led como salida }

void loop(){ estado1 = digitalRead(var1); //Lee el estado del botón y lo almacena estado2 = digitalRead(var2); //Lee el estado del botón y lo almacena resultado = (estado1 && estado2); //Función AND con los dos estados digitalWrite(led, resultado); //Escribimos el resultado en el led } ```

Montaje 1bis AND con EDUBASICA

En este caso, para ahorrar cableado, vamos a utilizar:

• Como variable 1 de entrada el pin D2 que ya tiene el pulsador, y lo visualizaremos en el pin D4 que tiene el LED VERDE.
• Como variable 2 de entrada el pin D5 que lo conectaremos con un cable a V1 que tiene el interruptor y ya se visualiza en el LED AMARILLO.
• Como variable de salida el pin D3 que es el LED ROJO.

El esquema sería el siguiente:

Y el esquema de conexiones es muy fácil, conectar V1 con el agujero D5 de JP6:

Aquí teneis el detalle de dónde está el agujero D5

El código sería:

/*
  Boole
  Función AND con 2 variables
 */
//////////////////// entradas ///////////////////////////////////////////////////////////////////////////
int var1 = 2;       //Pin D2 de entrada del pulsador 1
int var2 = 5;       //Pin D5 de entrada del pulsador 1 y led(rojo), conectamos V1 con D5 con un cable
int ledvar1 = 4;    //Pin D4 de salida para el var1 led(amarillo)
//////////////////// salidas /////////////////////////////////////////////////////////////////////////
int ledsalida = 3;    //Pin de salida para el led(verde)
////////////////////////////////////////////////////////////////////////////////////////////////////
int estado1 = 0;    //Para almacenar el estado de la variable1
int estado2 = 0;    //Para almacenar el estado de la variable2
int resultado = 0;  //Para almacenar el resultado      

void setup() {
  pinMode(var1, INPUT);         //Iniciliza el pin de entrada 1 como salida
  pinMode(var2, INPUT);         //Iniciliza el pin de entrada 2 como salida  
  pinMode(ledvar1, OUTPUT);     //Inicialliza led de var1 como salida
  ///////////////////////////////// no hace falta inicializar D5 como salida, pues estará con un cable visualizando V1
  pinMode(ledsalida, OUTPUT);     //Iniciliza el pin del led como salida 
}

void loop(){
  estado1 = digitalRead(var1);      //Lee el estado del botón y lo almacena
  digitalWrite(ledvar1, estado1);   //Se visualiza en el led amarillo la entrada var1
  estado2 = digitalRead(var2);      //Lee el estado del botón y lo almacena

  resultado = (estado1 && estado2); //Función AND con los dos estados
  digitalWrite(ledsalida, resultado);    //Escribimos el resultado en el led
}

Y el resultado es :

Montaje 2 ELEVADOR sin EDUBASICA

FUNCIONES LÓGICAS:

Tenemos un elevador neumático que se puede controlar desde 2 habitaciones contiguas del taller. Para que el elevador funcione debe estar accionado cualquiera de los 2 pulsadores existentes, pero por seguridad no funcionará si dos operarios la accionan simultáneamente.

Identificar las variables de entrada y función de salida:

Entradas:

• A: un pulsador
• B: un pulsador

Salida o valor de la función:

• Motor que acciona el compresor del elevador

TABLA DE VERDAD:

Función Canónica: M(FC1) = NOT(A) * B + A * NOT(B)

Puertas Lógicas:

• 2 puertas NOT
• 2 puertas AND
• 1 puerta OR

(Es decir, una función XOR)

PROGRAMA:

```cpp / Implementación de Función lógica /

int var1 = 1; //Pin de entrada del pulsador 1 int var2 = 2; //Pin de entrada del pulsador 1 int led = 5; //Pin de salida para el led(rojo)

int A = 0; //Para almacenar el estado de la variable1 int B = 0; //Para almacenar el estado de la variable2 int resultado = 0; //Para almacenar el resultado

void setup() { pinMode(var1, INPUT); //Init pin de entrada 1 como salida pinMode(var2, INPUT); //Init pin de entrada 2 como salida
pinMode(led, OUTPUT); //Iniciliza el pin del led como salida }

void loop(){ A = digitalRead(var1); //Lee el estado 1 y lo almacena B = digitalRead(var2); //Lee el estado 2 y lo almacena //Función Lógica ------ R=(âb)+(a^b) resultado = (!A && B) || (A && !B); digitalWrite(led, resultado); //Escribimos el resultado en el led } ```

Montaje 2bis ELEVADOR con EDUBASICA

Con EDUBASICA es utilizar el mismo esquema que AND con EDUBASICA pero cambiando la función AND por la XOR

/*
  Boole
  Función XOR con 2 variables
 */
//////////////////// entradas ///////////////////////////////////////////////////////////////////////////
int var1 = 2;       //Pin D2 de entrada del pulsador 1
int var2 = 5;       //Pin D5 de entrada del pulsador 1 y led(rojo), conectamos V1 con D5 con un cable
int ledvar1 = 4;    //Pin D4 de salida para el var1 led(amarillo)
//////////////////// salidas /////////////////////////////////////////////////////////////////////////
int ledsalida = 3;    //Pin de salida para el led(verde)
////////////////////////////////////////////////////////////////////////////////////////////////////
int A = 0;    //Para almacenar el estado de la variable1
int B = 0;    //Para almacenar el estado de la variable2
int resultado = 0;  //Para almacenar el resultado      

void setup() {
  pinMode(var1, INPUT);         //Iniciliza el pin de entrada 1 como salida
  pinMode(var2, INPUT);         //Iniciliza el pin de entrada 2 como salida  
  pinMode(ledvar1, OUTPUT);     //Inicialliza led de var1 como salida
  ///////////////////////////////// no hace falta inicializar D5 como salida, pues estará con un cable visualizando V1
  pinMode(ledsalida, OUTPUT);     //Iniciliza el pin del led como salida 
}

void loop(){
  A = digitalRead(var1);      //Lee el estado del botón y lo almacena
  digitalWrite(ledvar1, A);   //Se visualiza en el led amarillo la entrada var1
  B = digitalRead(var2);      //Lee el estado del botón y lo almacena
  resultado = (!A && B) || (A && !B);
  digitalWrite(ledsalida, resultado);    //Escribimos el resultado en el led
}

El resultado es: