EVALUACION SUMATIVA 1
RESPONDER CADA UNA DE LAS SIGUIENTES PREGUNTAS DE OPCION MULTIPLE:
EVALUACION SUMATIVA 1
RESPONDER CADA UNA DE LAS SIGUIENTES PREGUNTAS DE OPCION MULTIPLE:
El circuito mostrado es un puente H, un sistema ampliamente utilizado en electrónica para controlar motores de corriente continua (DC). Este circuito permite invertir la polaridad aplicada al motor, lo que a su vez cambia su dirección de giro. Además, también permite encender o apagar el motor sin necesidad de desconectar físicamente la fuente de alimentación.
El puente H consta de cuatro transistores (Q1, Q2, Q3 y Q4),
cuatro diodos (D1, D2, D3 y D4),
y resistencias de polarización (R1, R2, R3 y R4).
Cada componente cumple una función específica en el control del motor de DC conectado en el centro del puente.
Los transistores utilizados son del tipo
NPN y actúan como interruptores electrónicos. Cuando un pin digital del
microcontrolador (Arduino, en este caso) activa la base de un transistor, este
permite el paso de corriente desde el colector hacia el emisor. Esto hace que
el motor reciba corriente en la dirección deseada.
La combinación de transistores que se activa determina la dirección de giro del
motor:
- Si Q1 y Q4 están encendidos, el motor gira en un sentido.
Los diodos están conectados en paralelo con los transistores y cumplen la función de protección. Cuando el motor cambia de dirección o se detiene, genera un voltaje inverso debido a su inercia. Este fenómeno, conocido como fuerza contraelectromotriz, podría dañar los transistores. Los diodos permiten que esta corriente inversa fluya de manera segura, protegiendo el circuito.
Las resistencias conectadas a las bases de los transistores limitan la corriente que fluye hacia estas, evitando daños en los transistores y en el microcontrolador. Además, aseguran un funcionamiento estable al evitar activaciones accidentales por ruido eléctrico.
1. **Motor en reposo**: Si todos los
transistores están apagados, no fluye corriente hacia el motor y este permanece
detenido.
2. **Giro en un sentido**: Cuando Q1 y Q4 están activados, la corriente fluye
desde la fuente de alimentación (+) a través de Q1, el motor, y finalmente a
tierra a través de Q4. Esto genera un campo magnético que hace girar el motor
en una dirección específica.
El puente H es un circuito esencial en el control de motores de corriente continua, permitiendo cambiar su dirección de giro de manera eficiente y segura. Los transistores actúan como interruptores controlados por el microcontrolador, mientras que los diodos y resistencias aseguran la protección y estabilidad del sistema. Este diseño es ideal para aplicaciones de robótica y automatización.
1 EJERCICIO DE SIMULACION PUENTE H CON TRANSISTORES:
SIMULAR EL SIGUIENTE CIRCUITO EN TINKERCAD ( PUENTE H CON TRANSISTORES )
2 EJERCICIO DE SIMULACION PUENTE H CON ARDUINO E INTEGRADO L293D:
SIMULAR EL SIGUIENTE CIRCUITO EN TINKERCAD ( PUENTE H CON INTEGRADO L293D
3 EJERCICIO DE SIMULACION PUENTE H CON ARDUINO E INTEGRADO L293D CON BOTON Y COMANDO IF ELSE):
SIMULAR UN CIRCUITO SIMILAR AL DEL EJERCICIO 2 Y QUE SE ACTIVE CON UN PULSADOR USANDO LOS COMANDOS IF ELSE.
Un botón pulsador (push button) es un componente electrónico comúnmente utilizado en proyectos con Arduino para interactuar con el usuario, como encender o apagar un LED o cambiar estados de un sistema.
El botón pulsador es un interruptor momentáneo con cuatro patas. Este dispositivo tiene dos pares de pines internos que están conectados entre sí. En TinkerCAD, estos pines son denominados Terminales 1 y Terminales 2:
Cuando el botón no está presionado, los pines de los Terminales 1 y Terminales 2 están desconectados. Al presionar el botón, los dos pares de pines se conectan eléctricamente, cerrando el circuito.
Para usar un botón pulsador en Arduino, es común utilizar una resistencia pull-up interna, lo que simplifica la conexión y evita la necesidad de una resistencia externa.
Conexión con resistencia pull-up interna:
INPUT_PULLUP
, lo que asegura que el pin esté en HIGH cuando el botón no está presionado y en LOW cuando el botón está presionado.const int buttonPin = 2; // Pin donde está conectado el botón
const int ledPin = 13; // Pin del LED
int buttonState = 0;
void setup() {
pinMode(buttonPin, INPUT_PULLUP); // Configura el botón con resistencia pull-up interna
pinMode(ledPin, OUTPUT); // Configura el LED como salida
}
void loop() {
buttonState = digitalRead(buttonPin); // Lee el estado del botón
if (buttonState == LOW) { // Si el botón está presionado (LOW)
digitalWrite(ledPin, HIGH); // Enciende el LED
} else {
digitalWrite(ledPin, LOW); // Apaga el LED
}
}
En este código, cuando el botón es presionado (y el estado es LOW), el LED se enciende. Cuando el botón no está presionado, el LED se apaga.
Si se prefiere utilizar una resistencia pull-down externa en lugar de la resistencia pull-up interna, se conecta de la siguiente manera:
El botón pulsador es conocido en Arduino como "push button". En TinkerCAD, se presenta con los terminales Terminal 1 y Terminal 2, que se usan para completar el circuito al presionar el botón. En Arduino, se puede utilizar la resistencia pull-up interna para simplificar el diseño del circuito, eliminando la necesidad de una resistencia externa.
En un Arduino, el sketch (programa) interactúa con la memoria y el procesador de la siguiente manera:
Procesador: El procesador (como el ATmega328P en el Arduino Uno) ejecuta las instrucciones del sketch, procesando datos y tomando decisiones en tiempo real.
Memoria Flash: El sketch se almacena aquí de forma permanente cuando lo cargas en el Arduino. Es la memoria de programa donde las instrucciones quedan guardadas.
SRAM (Memoria RAM): Se utiliza para variables y datos que cambian durante la ejecución del sketch. Por ejemplo, contadores, estados de sensores, etc.
EEPROM: Almacena datos que deben persistir después de apagar el Arduino, como configuraciones que quieres guardar.
Cuando el sketch se ejecuta:
La ley de Ohm establece que la corriente (I) que circula por un circuito eléctrico es directamente proporcional al voltaje (V) aplicado e inversamente proporcional a la resistencia (R).
Se expresa con la fórmula:
V = I × R.
En Arduino, esta ley es útil para calcular la resistencia necesaria para proteger un LED. Por ejemplo, si conectamos un LED que opera a 2V y la corriente deseada es de 20mA (0.02A), y el voltaje de salida del pin es de 5V, la resistencia se calcula así:
R = (5V - 2V) / 0.02A = 150Ω
Ejemplo para Tinkercad:
https://youtu.be/hR8Xw098rdc?si=feM4VJpvR5HPINV5
Un circuito en serie conecta componentes uno tras otro, de modo que la misma corriente pasa por todos ellos. En cambio, en un circuito en paralelo, los componentes comparten el mismo voltaje, pero la corriente se divide entre ellos.
En Arduino, podemos simular circuitos en serie y paralelo al conectar varios LEDs con resistencias, asegurándonos de calcular correctamente las resistencias para evitar daños.
Aquí tienes dos ejemplos prácticos en Arduino para circuitos serie y paralelo con LEDs.
Circuito en Serie con LEDs
En un circuito en serie, la misma corriente pasa a través de todos los LEDs. El voltaje total se reparte entre los componentes, así que es importante asegurarse de que el voltaje total del circuito sea suficiente.
Conecta dos LEDs en serie.
Coloca una resistencia limitadora en serie con los LEDs.
Código:
int ledPin = 13; // Pin para alimentar los LEDs en serie
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
digitalWrite(ledPin, HIGH); // Encender los LEDs
delay(1000); // Esperar 1 segundo
digitalWrite(ledPin, LOW); // Apagar los LEDs
delay(1000); // Esperar 1 segundo
}
Notas:
El cálculo de la resistencia depende de la suma de los voltajes de los LEDs.
Por ejemplo, si cada LED necesita 2V y la fuente es de 5V:
.
---
Conecta dos o más LEDs en paralelo.
Asegúrate de que cada LED tenga su propia resistencia.
Código:
int led1 = 8; // Primer LED conectado al pin 8
int led2 = 9; // Segundo LED conectado al pin 9
void setup() {
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
}
void loop() {
digitalWrite(led1, HIGH); // Encender el primer LED
digitalWrite(led2, HIGH); // Encender el segundo LED
delay(1000); // Esperar 1 segundo
digitalWrite(led1, LOW); // Apagar el primer LED
digitalWrite(led2, LOW); // Apagar el segundo LED
delay(1000); // Esperar 1 segundo
}
Notas:
Cada resistencia se calcula individualmente.
Por ejemplo, si un LED necesita 2V y la corriente es de 20mA (0.02A), usando una fuente de 5V:
.
---
Ambos ejemplos son útiles para comprender cómo distribuir los componentes en un circuito y cómo afecta la conexión (serie o paralelo) a las propiedades eléctricas del sistema. ¿Te gustaría que prepare un archivo con los esquemas o simulaciones?
Las leyes de Kirchhoff describen cómo se comportan las corrientes y tensiones en un circuito:
- Ley de las mallas: La suma de todas las tensiones en un circuito cerrado es igual a cero.
- Ley de los nodos: La suma de las corrientes que entran a un nodo es igual a la suma de las corrientes que salen.
Estas leyes son útiles para analizar circuitos complejos y son fundamentales en el diseño electrónico.
Ejemplo circuito mixto con ley de kirchoff:
Un diodo es un componente que permite el flujo de corriente en una sola dirección. Cuando se polariza directamente (ánodo más positivo que el cátodo), conduce; en caso contrario, no lo hace.
Un diodo LED funciona de manera similar, pero emite luz al conducir corriente. Es importante usar una resistencia limitadora para evitar que el exceso de corriente lo dañe.
Un transistor es un dispositivo que amplifica señales o actúa como un interruptor controlado. Cuando se aplica suficiente voltaje a la base (B), permite que la corriente fluya entre el colector (C) y el emisor (E).
Por ejemplo, en configuración de amplificación, el transistor puede aumentar una señal de entrada proporcional a su ganancia (β).
Un puente H es un circuito que permite controlar el sentido de giro de un motor DC. Utiliza cuatro transistores o interruptores dispuestos en forma de H. Activando diferentes combinaciones de transistores, se puede cambiar la dirección de la corriente en el motor.
Ejemplo en Arduino: Usando un controlador como el L298N, podemos controlar un motor conectándolo a los pines de salida y enviando señales digitales para cambiar el sentido de giro.
Cuando ingresas una señal al puerto de sensores analógicos en Arduino, lo primero que hace Arduino es convertir la señal analógica en una señal digital mediante un convertidor analógico-digital (ADC).
Este proceso ocurre en los siguientes pasos:
Muestreo: Arduino toma un valor instantáneo de la señal analógica.
Para convertir un valor de temperatura de 23°C a una representación de 10 bits en Arduino, sigues estos pasos:
Arduino mide voltajes, no temperaturas, por lo que necesitas conocer cómo el sensor traduce la temperatura en voltaje. Supongamos que usas un sensor LM35, que entrega 10 mV por cada °C.
El sensor LM35 entrega:
El conversor ADC de Arduino toma valores entre 0V y 5V, asignando 1024 niveles (0-1023). La conversión es:
Sustituyendo valores:
Por lo tanto, el valor digital almacenado en Arduino será 47 (en decimal), que en binario de 10 bits es:
Para recuperar la temperatura:
Luego, usando la conversión del sensor LM35:
De temperatura a digital:
De digital a temperatura:
Este mismo proceso aplica para cualquier sensor que entregue una señal analógica. ¿Quieres un código en Arduino para probarlo?
La comunicación serial es un método para enviar y recibir datos secuencialmente, bit por bit, a través de un solo canal de datos. En Arduino, se utiliza principalmente para la transmisión de datos entre la placa y otros dispositivos, como computadoras, módulos de comunicación o sensores avanzados.
El Monitor Serial en Arduino es una herramienta integrada en el Entorno de Desarrollo Integrado (IDE) que permite la comunicación entre la placa Arduino y un ordenador. A través de esta interfaz, es posible enviar y recibir datos en formato de texto, lo cual es especialmente útil para depurar programas, monitorear valores de sensores en tiempo real y controlar dispositivos conectados a la placa desde el ordenador.
Para utilizar el Monitor Serial, es necesario inicializar la comunicación serie en el programa de Arduino mediante la función Serial.begin(velocidad)
, donde "velocidad" es la tasa de baudios, comúnmente 9600. Una vez establecida la comunicación, se pueden emplear las funciones Serial.print()
y Serial.println()
para enviar datos al ordenador, y Serial.read()
para recibir datos desde el mismo.
El Monitor Serial es una herramienta esencial para el desarrollo de proyectos con Arduino, ya que facilita la interacción y el intercambio de información entre la placa y el usuario, permitiendo una mejor comprensión y control del comportamiento del programa.
ACTIVIDAD 1
int valor; // Declaramos una variable llamada "valor" que almacenará datos del sensor
void setup() {
pinMode(LED_BUILTIN, OUTPUT); // Configuramos el LED interno de la placa como salida
}
void loop() {
analogRead(A3); // Leemos el valor del sensor conectado a la entrada analógica A3
digitalWrite(LED_BUILTIN, HIGH); // Encendemos el LED interno
delay(1000); // Esperamos 1 segundo (1000 milisegundos)
digitalWrite(LED_BUILTIN, LOW); // Apagamos el LED interno
delay(1000); // Esperamos otro segundo antes de repetir el ciclo
}
int valor;
valor
, que se usará para almacenar datos de un sensor.valor
, en otros programas puede ser útil para guardar datos y hacer cálculos con ellos.void setup() {
pinMode(LED_BUILTIN, OUTPUT);
pinMode()
es una función que configura un pin para que funcione como entrada (INPUT
) o salida (OUTPUT
).LED_BUILTIN
es el LED que ya viene en la placa Arduino (normalmente en el pin 13).OUTPUT
, indicamos que lo vamos a encender y apagar en el programa.void loop() {
analogRead(A3);
analogRead()
lee valores de una entrada analógica (en este caso, el pin A3
).digitalWrite(LED_BUILTIN, HIGH);
digitalWrite()
cambia el estado de un pin digital.HIGH
significa encender el LED.delay(1000);
delay()
pausa la ejecución del código durante un tiempo determinado en milisegundos.1000
significa que el programa se detiene por 1 segundo antes de continuar.digitalWrite(LED_BUILTIN, LOW);
LOW
significa apagar el LED.delay(1000);
Si quieres que el valor del sensor se muestre en la computadora a través del Monitor Serial, puedes modificar el código agregando lo siguiente:
void loop() {
valor = analogRead(A3); // Leer el sensor y almacenar el valor en "valor"
Serial.println(valor); // Enviar el valor al Monitor Serial
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Y en el setup()
, agrega Serial.begin(9600);
para habilitar la comunicación:
void setup() {
Serial.begin(9600); // Iniciar la comunicación con el PC
pinMode(LED_BUILTIN, OUTPUT);
}
Así, podrás ver en la pantalla cómo cambia el valor del sensor en tiempo real.
ACTIVIDAD 2
En esta guía de 10 ejercicios, se usarán tres interruptores de deslizamiento como entradas y un LED como salida. Se implementarán tablas de verdad que combinen operaciones lógicas como AND, OR, y NOT para controlar el estado del LED. Cada ejercicio está diseñado para reforzar conceptos de lógica digital y programación en C++ con Arduino.
LED = Entrada1 AND Entrada2 AND Entrada3
.if (state1 && state2 && state3) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
LED = Entrada1 OR Entrada2 OR Entrada3
.if (state1 || state2 || state3) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
(Entrada1 XOR Entrada2 XOR Entrada3)
.if ((state1 + state2 + state3) == 1) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
LED = NOT Entrada1
.if (!state1) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
(Entrada1 + Entrada2 + Entrada3) == 2
.if ((state1 + state2 + state3) == 2) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
LED = NOT (Entrada1 OR Entrada2 OR Entrada3)
.if (!state1 && !state2 && !state3) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
LED = NOT (Entrada1 AND Entrada2 AND Entrada3)
.if (!(state1 && state2 && state3)) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
if (state1) {
digitalWrite(ledPin, HIGH);
} else if (state2) {
digitalWrite(ledPin, HIGH);
} else if (state3) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
LED = NOT Entrada1 AND Entrada2 AND Entrada3
.if (!state1 && state2 && state3) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
delay()
) si las tres entradas están en HIGH.if (state1 && state2 && state3) {
digitalWrite(ledPin, HIGH);
delay(500);
digitalWrite(ledPin, LOW);
delay(500);
} else {
digitalWrite(ledPin, LOW);
}
Estos ejercicios cubren desde lo básico hasta combinaciones más avanzadas de lógica booleana y control de salida. Los estudiantes pueden simularlos en Tinkercad, verificar sus tablas de verdad y comprender cómo las operaciones lógicas controlan dispositivos electrónicos. ¿Necesitas algo adicional?
Acumulativa 1: Enviar al profesor un link en tinkercad de la simulación para cada uno de estos ejercicios.
Detalles importantes:
1-El correo debe llevar un asunto acorde a este ejemplo:
a1 diames apellidoalumno
Por ejemplo: a1 210125 olmos
2-La simulacion en tinkercad debe llevar este nombre:
a1 diames apellidoalumno
Por ejemplo: a1 210125 olmos
3-Para nota maxima debe estregarse dia jueves antes de las las 19 30 horas.
El LED se enciende solo si el interruptor 1 está en HIGH.
El LED se enciende solo si el interruptor 1 y el interruptor 2 están ambos en HIGH.
El LED se enciende si al menos uno de los interruptores 1, 2 o 3 está en HIGH.
El LED se enciende solo si el interruptor 3 está en LOW.
El LED se enciende solo si el interruptor 1 está en HIGH y el interruptor 2 está en LOW.
El LED se enciende si exactamente dos interruptores están en HIGH.
El LED se enciende si el interruptor 1 está en HIGH, o si el interruptor 2 y el interruptor 3 están ambos en HIGH.
El LED se apaga solo si todos los interruptores están en HIGH.
El LED se enciende solo si el interruptor 1 y el interruptor 2 están en HIGH y el interruptor 3 está en LOW.
El LED se enciende solo si el interruptor 1 está en HIGH, y el interruptor 2 y el interruptor 3 están en el mismo estado (ambos en HIGH o ambos en LOW).
En estos ejercicios solo se usan las operaciones AND, OR y NOT para determinar el estado del LED en función de los interruptores.
Además debes usar if y else.
Relog cristal oscilador
Físicamente, un cristal oscilador (también llamado oscilador de cristal o simplemente "cristal") es un componente electrónico que genera una señal de reloj estable y precisa para sincronizar los circuitos electrónicos. Este dispositivo se basa en las propiedades mecánicas y eléctricas del material cristalino, generalmente cuarzo, que puede oscilar a frecuencias específicas cuando se aplica una corriente eléctrica.
Componentes físicos y principio de funcionamiento:
El cristal de cuarzo:
Circuito electrónico asociado:
Encapsulado del cristal oscilador:
El cristal oscilador actúa como el "ritmo cardíaco" del microcontrolador:
Por ejemplo, un cristal de 16 MHz genera 16 millones de ciclos de reloj por segundo. Esto significa que cada operación del microcontrolador se basa en este ritmo constante.
En una placa Arduino, el cristal oscilador asegura:
En resumen, físicamente el cristal oscilador es un dispositivo mecánico y eléctrico que convierte las oscilaciones naturales del cuarzo en una señal electrónica precisa, sirviendo como el "ritmo" del sistema en circuitos electrónicos como el Arduino.
Físicamente, un cristal oscilador (también llamado oscilador de cristal o simplemente "cristal") es un componente electrónico que genera una señal de reloj estable y precisa para sincronizar los circuitos electrónicos. Este dispositivo se basa en las propiedades mecánicas y eléctricas del material cristalino, generalmente cuarzo, que puede oscilar a frecuencias específicas cuando se aplica una corriente eléctrica.
El cristal de cuarzo:
Circuito electrónico asociado:
Encapsulado del cristal oscilador:
El cristal oscilador actúa como el "ritmo cardíaco" del microcontrolador:
Por ejemplo, un cristal de 16 MHz genera 16 millones de ciclos de reloj por segundo. Esto significa que cada operación del microcontrolador se basa en este ritmo constante.
En una placa Arduino, el cristal oscilador asegura:
En resumen, físicamente el cristal oscilador es un dispositivo mecánico y eléctrico que convierte las oscilaciones naturales del cuarzo en una señal electrónica precisa, sirviendo como el "ritmo" del sistema en circuitos electrónicos como el Arduino.
Físicamente, un cristal oscilador (también llamado oscilador de cristal o simplemente "cristal") es un componente electrónico que genera una señal de reloj estable y precisa para sincronizar los circuitos electrónicos. Este dispositivo se basa en las propiedades mecánicas y eléctricas del material cristalino, generalmente cuarzo, que puede oscilar a frecuencias específicas cuando se aplica una corriente eléctrica.
Veamos cómo se relaciona la ejecución de una línea de código (como un if) con los ciclos de reloj generados por el cristal en un Arduino. Esto te ayudará a entender cómo la frecuencia del cristal impacta directamente en el tiempo que toma procesar una instrucción.
Ejemplo de código
Supongamos que tienes esta línea de código en C++ dentro de un programa de Arduino:
if (x == 10) {
digitalWrite(LED_BUILTIN, HIGH);
}
Proceso interno del microcontrolador
Cuando el Arduino ejecuta este código, realiza una serie de pasos, y cada paso requiere ciclos de reloj. Estos ciclos son impulsados por la frecuencia del cristal (por ejemplo, 16 MHz en el caso del Arduino Uno).
Desglose del proceso:
1. Evaluación del if (x == 10):
El microcontrolador compara el valor de la variable x con el valor constante 10.
Esta comparación implica una operación lógica, que puede requerir 1 a 2 ciclos de reloj dependiendo del registro o memoria utilizada.
2. Ejecución de la instrucción digitalWrite:
digitalWrite no es una instrucción única del microcontrolador; es una función que realiza varias operaciones internas:
Traducción del pin lógico al puerto físico.
Configuración del puerto en modo de salida.
Cambio del nivel lógico del pin.
Dependiendo de la implementación, esta función puede tardar cientos de ciclos de reloj, ya que incluye varias instrucciones de bajo nivel.
Conclusión
Cada línea de tu programa se traduce en múltiples instrucciones a nivel de máquina, y estas instrucciones requieren ciclos de reloj para ejecutarse. La frecuencia del cristal determina cuántos ciclos de reloj se pueden realizar por segundo, lo que afecta directamente el tiempo necesario para ejecutar tu código. Por ejemplo, en un Arduino Uno, una función simple como digitalWrite toma del orden de microsegundos debido al número de ciclos implicados y la frecuencia del cristal.
Vamos a describir las 21 partes señaladas en la imagen de la placa Arduino UNO:
1. ATmega 328 microcontrolador. El corazón de nuestro Arduino, el procesador.
Memoria: Cuenta con 32 KB de memoria flash para almacenar programas, 2 KB de SRAM para datos temporales y 1 KB de EEPROM para almacenamiento de datos no volátiles.
2. Puerto USB. Se utiliza para la alimentación de la interfaz Uno Genuino, la carga de nuestros programas, y para la comunicación con nuestra placa (a través de serie. PrintIn (), etc.). El regulador de tensión ubicado a su lado, convertirá la tensión que le llega a través de este puerto usb y hará que trabaje a 5V.
3. Conector de alimentación. Esta es la forma de alimentar nuestra placa cuando no está conectada a un puerto USB para para suministrarle corriente eléctrica. Puede aceptar tensiones entre 7-12V.
4. Los pines digitales:
Utilizaremos estos pines con instrucciones como digitalRead (), digitalWrite ().
analogRead () y analogWrite () funcionarán unicamente en los Pìnes con el símbolo PWM.
5. y 6. Serial IN (TX) y Serial IN (RX): Los puertos serie están físicamente unidos a distintos pines de la placa Arduino. Lógicamente, mientras usamos los puertos de serie no podemos usar como entradas o salidas digitales los pines asociados con el puerto de serie en uso. Pines asociados con el puerto de serie como entrada y salida digital (TX es el que Transmite y RX es el que recibe).
7. y 23. Pin 13 + L (on board led): El único actuador incorporado a la placa. Además de ser un objetivo práctico para nuestra primera práctica de encender y apagar LED, este LED es muy útil para la depuración (debugging).
8. GND: proporciona masa, tierra, negativo a nuestros circuitos.
9. AREF: analogReference input V- Tensión a 5V, proporciona diferencia de potencial. Si se le aplica voltaje externo debe ser entre 0 y 5V solamente.
10. Botón Reset. Restablece el microcontrolador ATmega.
11. Chip de comunicación serie.
12. Regulador de tensión. Tenemos que tener en cuenta que para que trabaje a 5V nuestra placa deberá recibir unos 6,5V – 7V, pero todo lo que esté por encima de este valor se desperdiciará (es decir, sobrecalentará nuestra placa de arduino y mayor calor que tendrá que dispar el regulador). En cualquier caso no está recomendado aplicar al regulador más de 12V y a los 20V se dañará.
13. ICSP: In-Circuit Serial Programming.
14. Led de encendido: Indica que nuestra placa está recibiendo alimentación.
15. Pines analógicos: Utilizaremos estos pines con instrucciones como analogRead ().
16. Vin: Voltaje Input. Deberá llegarle una tensión regulada y estable (ya que no pasa por el regulador -nº12-) de 5V.
17. GND: proporciona masa, tierra, negativo a nuestros circuitos.
18. 5V: Voltaje Input.
19. 3,3V: Voltaje Input.
20. Reset pin: Restablece el microcontrolador ATmega. A su izquierda está el conector IOREF: Digital Reference input V, y a continuación un pin reservado para futuras finalidades.
21. TX y RX LED. Estos LEDs indican la comunicación entre la placa y el ordenador. Estos leds parpadearán rápidamente durante la carga de nuestros programas, así como durante la comunicación serie. Útil para la depuración (debugging).
22. Casa fabricante original. Aquí puedes comprobar fácilmente si tu placa se trata de una imitación o el original.
24. Reloj / Crystal 16 Mhz oscilador: se usa como reloj externo en el montaje del Arduino.
PARTE 1 : SIMULACION Enunciado Diseñar un circuito con Arduino que mida la temperatura usando un sensor TMP36 y controle un servomotor, movi...