Para controlar la temperatura de un ambiente en un valor deseado prefijado (4 posibles {lcd.

{lcd.setCursor(8,0); //Con este comando decimos en que línea queremos escribir

valores), se tiene como sensor para medir la temperatura un LM35, para disminuir la lcd.print("Tem:####");
temperatura un ventilador variable en velocidad (señal de control de 0 a 5v). Si la }
temperatura medida es igual a la prefijada el ventilador deberá estar apagado (0%). if (Temp > 50)
{lcd.setCursor(8,0); //Con este comando decimos en que línea queremos escribir
lcd.print("Tem:###");
}
if (Temp > 25)
{lcd.setCursor(8,0); //Con este comando decimos en que línea queremos escribir
lcd.print("Tem:##");
}
if(Temp > 0);
{lcd.setCursor(8,0); //Con este comando decimos en que línea queremos escribir
lcd.print("Tem:#");
#include <LiquidCrystal.h> //Incluir esta librería para poder usar el lcd }
int Pot = A0; delay(500); //Al ser temperatura no hace falta leerlo tan seguido
int LM35 = A1; //Entrada analógica de LM35 }
int VT = 9; _____----
LiquidCrystal lcd(12,11,5,4,3,2); //Definimos la pantalla LCD Se desea fijar la velocidad de cuatro actuadores a partir de una única entrada de control.
int Temp = 0; Para ello el sistema de control deberá emplear como entrada un potenciómetro, las
int Vent = 0; salidas son en PW y deberán ser verificadas a través de la intensidad de LEDs
void setup(){ conectados como salidas.
analogReference(INTERNAL);
lcd.begin(16,2);
pinMode(13,OUTPUT);
digitalWrite(13, HIGH); //Activamos la retroiluminación
}
void loop(){
Vent = analogRead(Pot);
Vent = map(Vent,0,1023,0,100);
analogWrite(VT,Vent);
int AI = A0; //Entrada analógica
Temp = analogRead(LM35); //Leemos el valor de la entrada analógica
Temp = map(Temp,0,1023,0,100); //Escalamos la señal a grados centígrados int led1 = 11; //salida PWM
//Mostramos los grados en la pantalla LCD int led2 = 10;
int led3 = 6;
lcd.setCursor(0,0); //Con este comando decimos en que línea queremos escribir
int led4 = 5;
lcd.print("TM:");
int Pot = 0; //Variable de control
lcd.setCursor(3,0);
int Salida = 0; //Variable controlada
lcd.print(Temp);
lcd.setCursor(0,1); void setup () {
lcd.print("SP="); pinMode(led1,OUTPUT); //led1 como salida
pinMode(led2,OUTPUT); //led2 como salida
lcd.setCursor(3,1);
pinMode(led3,OUTPUT); //led3 como salida
lcd.print(Vent);
pinMode(led4,OUTPUT); //led4 como salida
lcd.setCursor(8,1);
}
lcd.print("Vnt");
lcd.setCursor(12,1); void loop () {
lcd.print(VT); Pot = analogRead(AI); //Lectura de la entrada analógica 0
Salida = map(AI,0,1023,0,255); // redimensiona de 0 a 255
lcd.setCursor(15,1);
analogWrite(led1,Salida); //escritura de la variable salida a el Led 1
lcd.print("%");
analogWrite(led2,Salida); //escritura de la variable salida a el Led 2
if (Temp > 75)
 analogWrite(led3,Salida); //escritura de la variable salida a el Led 3 printInteger(medida); //el valor de la señal de la NTC en la entrada analógica
analogWrite(led4,Salida); //escritura de la variable salida a el Led 4 printString(" ");
delay (50); delay(100); //para evitar saturar el puerto serie
} }
____-------- void loop(){
Programa Contador de 0 a 10 medida=analogRead(ntc);
int LED = 13; monitoriza();
int Boton = 7; if(medida>nivel){ //si la señal del sensor supera el nivel marcado:
int valor = 0; digitalWrite(led,HIGH); //se enciende un aviso luminoso
int contador = 0; }
int estadoanteriorboton = 0; else{ // si la señal está por debajo del nivel marcado
void setup() digitalWrite(led,LOW);
{ }
beginSerial(9600); // Configura velocidad de transmisión a 9600 }
pinMode(LED, OUTPUT); // inicializa como salida digital el pin 13 ______----
pinMode(Boton, INPUT); // inicializa como entrada digital el 7 Control de un motor CC con un transitor
} int valor = 0; // variable que contiene el valor a sacar por el terminal analógico
void loop() int motor = 10; // motor conectado al PIN 10
{ void setup() { } // No es necesario
valor = digitalRead(Boton); // lee el valor de la entrad digital pin 7 void loop() {
digitalWrite(LED, valor); for(valor = 0 ; valor <= 255; valor +=5) {
if(valor != estadoanteriorboton){ // se genera una rampa de subida de tensión de 0 a 255 es decir de 0 a 5v
if(valor == 1){ analogWrite(motor, valor);
contador++; delay(30); // espera 30 ms para que el efecto sea visible
printInteger(contador); }
serialWrite(10); for(valor = 255; valor >=0; valor -=5) {
serialWrite(13); // se genera una rampa de bajada de tensión de 255 a 0 es decir de 5 a 0v
if (contador==10) { // Limita la cuenta al valor 10 analogWrite(motor, valor);
contador=0; delay(30);
} }
} }
} _____-----
estadoanteriorboton = valor; Control de velocidad mediante un potenciómetro
} int valor = 0; // variable que contiene el valor a sacar por el terminal analógico
___------- int motor = 10; // motor conectado al PIN 10
Sensor de temperatura int potenciometro=0; // Se define la entrada analógica
//Detector de valor de temperatura void setup() { } // No es necesario
int led=13; void loop() {
int ntc=3; valor = analogRead(potenciometro); // lee la entrada analógica y se asigna a val
int medida=0; analogWrite(motor, valor); // Se manda a la salida analógica 0 el valor leído
//variable que guarda el límite de temperatura al que se activa el ventilador delay(30); // espera 30 ms para que el efecto sea visible
int nivel=500; }
void setup(){ _______-----
pinMode(led,OUTPUT); Control simple de un motor con el CI L293 a velocidad constante
pinMode(motor,OUTPUT); int motorpin =10; // PIN de salida analógica PWM
beginSerial(9600); void setup() { }
} void loop() {
//procedimiento que envía al puerto serie, para ser leído en el monitor, analogWrite(motorpin, 125); // activa el motor a una velocidad constante
void monitoriza(){ delay(100); // espera 100 ms para la próxima lectura
} //Ingresar nuevo piso
____---- nue=Serial.read();
Control de un motor: velocidad variable y sentido de giro variable Serial.println(nue, DEC);
int valor = 0; // variable que contiene el valor //Si el elevador se va a mover
int motorAvance = 10; // Avance motor --> PIN 10 if (nue!=0){
int motorRetroceso = 11; // Retroceso motor --> PIN 11 //Operaciones para detectar el nuevo nivel
void setup() { } // No es necesario //y saber cuántos pulsos (pisos) omitir para llegar
void loop() { //al destino
analogWrite(motorRetroceso, 0); // Motor hacia delante ... sube la velocidad con=nue-act;
for(valor = 0 ; valor <= 255; valor+=5) { act=nue;
analogWrite(motorAvance, valor); nue=0;
delay(30); //En el caso de bajar
} if (con<0){
for(valor = 255; valor >=0; valor-=5) { // Motor hacia delante baja la velocidad //Convertir el resultado a positivo
analogWrite(motorAvance, valor); con*=-1;
delay(30); //Echar a andar el motor
} digitalWrite(LeftPin,HIGH);
analogWrite(motorAvance, 0); // Motor hacia detrás ... sube la velocidad digitalWrite(RightPin,LOW);
for(valor = 0 ; valor <= 255; valor+=5) { delay(100);
analogWrite(motorRetroceso, valor); }
delay(30); //En el caso de subir
} else{
for(valor = 255; valor >=0; valor-=5) { // Motor hacia detrás ... baja la velocidad if (con>0){
analogWrite(motorRetroceso, valor); //Echar a andar el motor
delay(30); digitalWrite(LeftPin,LOW);
} digitalWrite(RightPin,HIGH);
} delay(700);
____----- }
ASCENSOR O ELEVADOR }
//Motor }
int LeftPin=2; }
int RightPin=3; //Si aun no se llega al destino
//Pisos if (con!=0){
int con=0; //Esperar pulso (piso)
//Piso actual buttonState = digitalRead(buttonPin);
int act=1; //Se detecta el pulso
//Piso destino if (buttonState == HIGH) {
int nue=0; //Restar uno al contador
//Sensor para detectar los pisos con--;
const int buttonPin = 8; //Es el destino? detener motor
int buttonState = 0; if(con<=0){
void setup(){ digitalWrite(LeftPin,LOW);
Serial.begin(9600); digitalWrite(RightPin,LOW);
pinMode(LeftPin,OUTPUT); }
pinMode(RightPin,OUTPUT); //Dar tiempo para omitir el pulkso y sebir subiendo/bajando
pinMode(buttonPin, INPUT); else{
} delay(100);
void loop(){ }
if (Serial.available()!=0) { }
 } EEPROM.write(0, 1);
}//Fin del Loop display1(pisoActual);
______------ display2(pisoActual);
OTRA FORMA DE ASCENSOR Serial.println(EEPROM.read(0));
#include <EEPROM.h> } else {
const int a = 2;///primer disp pisoActual=EEPROM.read(0);
const int b = 3; display1(pisoActual);
const int c = 4; display2(pisoActual);
const int d = 5; }
const int e = 6;/// segundo disp entrada1 = digitalRead(SW1);//// Asigno los sw a las variables entrada y le digo que las
const int f = 7; lea como 1 y 0
const int g = 8; entrada2 = digitalRead(SW2);
const int h = 9; if (entrada1 == HIGH) {
const int SW1 = A0; ///SW ---->> Significa interruptor piso 1 while (entrada1 == HIGH) {
const int SW2 = A1; entrada1 = digitalRead(SW1);
//const int SW3 = A2; }
const int REDSW = A5; display1(1);
const int Subir = 13; piso = 1;
const int Bajar = 12; if (pisoActual != piso) {
int entrada1 = 0; ///declaro las variables de entrada digital MoverAscensor(piso);
int entrada2 = 0; }
int entrada3 = 0; } else if (entrada2 == HIGH) {
int pisoActual = 0; while (entrada2 == HIGH) {
int piso = pisoActual; entrada2 = digitalRead(SW2);
int sensor = 0; //declaro la variable del sensor }
void setup() { display1(2);
Serial.begin(4800); piso = 2;
pinMode(a, OUTPUT);//// declaro los pines a,b,c,d,etc como salidas if (pisoActual != piso) {
pinMode(b, OUTPUT); MoverAscensor(piso);
pinMode(c, OUTPUT); }
pinMode(d, OUTPUT); }
pinMode(e, OUTPUT); }
pinMode(f, OUTPUT);
pinMode(g, OUTPUT); //funcion que mueve la cabina del ascensor
pinMode(h, OUTPUT); int pisoSubir = 0;
pinMode(Subir, OUTPUT); int i = 0;
pinMode(Bajar, OUTPUT); void MoverAscensor(int nuevoPiso) {
pinMode(SW1, INPUT); //// declaro los SWcomo entradas pisoSubir = nuevoPiso - pisoActual;
pinMode(SW2, INPUT); // + + + "-" +
// pinMode(SW3, INPUT); Serial.print("Me movere ");//texto a imprimir enla consola
pinMode(REDSW, INPUT); //declaro en pin A5(CNY70) como entrada Serial.print(pisoSubir);//texto a imprimir enla consola
digitalWrite(Subir, LOW); Serial.println(" pisos.");//texto a imprimir enla consola
digitalWrite(Bajar, LOW); if (nuevoPiso > pisoActual) {
Serial.println(EEPROM.read(0)); digitalWrite(Subir, HIGH);
} digitalWrite(Bajar, LOW);
void loop() { i = 0;
if (EEPROM.read(0) == 255) { ///bucle de subida
pisoActual = 1; while (i < pisoSubir) {
piso = 1; Serial.println("Subiendo...");//texto a imprimir enla consola
 sensor = digitalRead(REDSW); // variable estado de la entrada del REDSW }
if (sensor == HIGH) {
pisoActual++; void display2(int numero) {
EEPROM.write(0, pisoActual); switch (numero) {
i++; case 1:
delay(350); digitalWrite(e, HIGH);
display2(pisoActual); digitalWrite(f, LOW);
} digitalWrite(g, LOW);
} digitalWrite(h, LOW);
digitalWrite(Subir, LOW); break;
digitalWrite(Bajar, LOW); case 2:
digitalWrite(e, LOW);
} else if (nuevoPiso < pisoActual) { digitalWrite(f, HIGH);
digitalWrite(Subir, LOW); digitalWrite(g, LOW);
digitalWrite(Bajar, HIGH); digitalWrite(h, LOW);;
i = 0; break;
//bucle de bajada }
while (i > pisoSubir) { }
Serial.println("Bajando..."); ________----
sensor = digitalRead(REDSW); // Asigno a la variable sensor el estado de la entrada SEMAFORO
del REDSW int rojo=2; //definimos el valor del pin para el led rojo
if (sensor == HIGH) { int amarillo=4; //definimos el valor del pin para el led amarillo
pisoActual--; int verde=7; //definimos el valor del pin para el led verde
EEPROM.write(0, pisoActual); //** Programa **//
i--; void setup() {
delay(350); pinMode(verde,OUTPUT); //declaramos el pin verde como salida
display2(pisoActual); pinMode(amarillo,OUTPUT);//declaramos el pin amarillo como salida
} pinMode(rojo,OUTPUT); //declaramos el pin rojo como salida
} }
digitalWrite(Subir, LOW); void loop() {
digitalWrite(Bajar, LOW); digitalWrite(verde,HIGH); //encendemos el led rojo
} delay(2000); //esperamos 2 segundos
} digitalWrite(verde,LOW); //apagamos el led rojo
///// Funciones de los display's delay(500); //esperamos medio segundo
void display1(int numero) { digitalWrite(amarillo,HIGH); //encendemos el led amarillo
switch (numero) { delay(2000); //esperamos 2 segundos
case 1://0001 digitalWrite(amarillo,LOW); //apagamos el led amarillo
digitalWrite(a, HIGH); delay(500); //esperamos medio segundo
digitalWrite(b, LOW); digitalWrite(rojo,HIGH); //encendemos el led verde
digitalWrite(c, LOW); delay(2000); //esperamos 2 segundos
digitalWrite(d, LOW); digitalWrite(rojo,LOW); //apagamos el led verde
break; delay(500); //esperamos medio segundo
case 2://0010 }
digitalWrite(a, LOW); ____------
digitalWrite(b, HIGH); SEMAFORO QUE CAMBIA DE UNO a otro, y la implementación de un boton
digitalWrite(c, LOW); para terminar el tiempo de la luz verde y pasar al otro.
digitalWrite(d, LOW);; const int button = 8;
break;
}
 void semaphoreTwo() {
void setup() { digitalWrite(5, HIGH);
// Con un ciclo activamos los pines del 2 al 7 como salidas int count = 0;
for (int pin = 2; pin <= 7; pin++) { while (count < 30) {
pinMode(pin, OUTPUT); if (digitalRead(button) == true) {
} break;
// El pin del boton lo ponemos como entrada }
pinMode(button, INPUT); count++;
} delay(200);
}
// Funcion para el primer semaforo y sus cambios de estado digitalWrite(5, LOW);
void semaphoreOne() { delay(500);
digitalWrite(2, HIGH); digitalWrite(5, HIGH);
int count = 0; delay(500);
while (count < 30) { digitalWrite(5, LOW);
// El ciclo esta en espera mientras el boton no es presionado delay(500);
if (digitalRead(button) == true) { digitalWrite(5, HIGH);
break; delay(500);
} digitalWrite(5, LOW);
count++; delay(500);
delay(200); digitalWrite(5, HIGH);
} delay(500);
digitalWrite(2, LOW); digitalWrite(5, LOW);
delay(500); delay(500);
digitalWrite(2, HIGH); digitalWrite(5, HIGH);
delay(500); delay(500);
digitalWrite(2, LOW); digitalWrite(5, LOW);
delay(500); digitalWrite(6, HIGH);
digitalWrite(2, HIGH); delay(2500);
delay(500); digitalWrite(6, LOW);
digitalWrite(2, LOW); digitalWrite(7, HIGH);
delay(500); digitalWrite(4, LOW);
digitalWrite(2, HIGH); // Mandamos a llamar al otro semaforo
delay(500); semaphoreOne();
digitalWrite(2, LOW); }
delay(500);
digitalWrite(2, HIGH); // Iniciamos nuestro semaforo
delay(500); void loop() {
digitalWrite(2, LOW); // Cambiamos el estado de todos los leds para
digitalWrite(3, HIGH); // que esten apagados todos al inicio
delay(2500); for (int pin = 2; pin <= 7; pin++) {
digitalWrite(3, LOW); digitalWrite(pin, LOW);
digitalWrite(4, HIGH); }
digitalWrite(7, LOW); // Prendemos el verde de un semaforo y el
// Mandamos a llamar al otro semaforo // rojo del otro semaforo
semaphoreTwo(); digitalWrite(2, HIGH);
} digitalWrite(7, HIGH);
// Iniciamos el primer semaforo
// Funcion para el segundo semaforo y sus cambios de estado semaphoreOne();
 } activo1 = false;
___________----- }
OTRO SEMAFORO }
// Pines utilizados else
#define LEDVERDE1 2 {
#define LEDAMARILLO1 3 // Está encendido el semáforo 1, comprobamos el pulsador 1
#define LEDROJO1 4 int valor1 = digitalRead(PULSADOR1);
#define LEDVERDE2 5 // Si hay un coche esperando, pulsador pulsado
#define LEDAMARILLO2 6 if (valor1 == HIGH)
#define LEDROJO2 7 {
#define PULSADOR1 8 // Encender semáforo 1
#define PULSADOR2 9 encenderSemaforo1();
// Variables // Semáforo 1 activo
bool activo1 = true; // Indica si el semáforo 1 está activo, de lo contrario será el semáforo activo1 = true;
2 }
int tiempoCambio = 1500; // Tiempo de espera entre transición de LEDs }
int tiempoEspera = 5000; // Tiempo de espera hasta comenzar transición }
void setup() { void ecenderSemaforo2()
// Iniciamos el monitor serie {
Serial.begin(9600); // Apagamos semáforo 1
// Modo entrada/salida de los pines // Esperamos
pinMode(LEDVERDE1, OUTPUT); delay(tiempoEspera);
pinMode(LEDAMARILLO1, OUTPUT); // Pasamos a luz amarilla
pinMode(LEDROJO1, OUTPUT); digitalWrite(LEDVERDE1, LOW);
pinMode(LEDVERDE2, OUTPUT); digitalWrite(LEDAMARILLO1, HIGH);
pinMode(LEDAMARILLO2, OUTPUT); // Esperamos
pinMode(LEDROJO2, OUTPUT); delay(tiempoCambio);
pinMode(PULSADOR1, INPUT); // Pasamos a luz roja
pinMode(PULSADOR2, INPUT); digitalWrite(LEDAMARILLO1, LOW);
// Apagamos todos los LEDs digitalWrite(LEDROJO1, HIGH);
digitalWrite(LEDVERDE1, LOW); // Encendemos semáforo 2
digitalWrite(LEDAMARILLO1, LOW); // Esperamos
digitalWrite(LEDROJO1, LOW); delay(tiempoCambio);
digitalWrite(LEDVERDE2, LOW); // Pasamos a luz amarilla
digitalWrite(LEDAMARILLO2, LOW); digitalWrite(LEDROJO2, LOW);
digitalWrite(LEDROJO2, LOW); digitalWrite(LEDVERDE2, HIGH);
// Estado inicial: semáforo 1 abierto, semáforo 2 cerrado }
digitalWrite(LEDVERDE1, HIGH); void ecenderSemaforo1()
digitalWrite(LEDROJO2, HIGH); {
} // Apagamos semáforo 2
void loop() { // Dependiendo del semáforo que tengamos activo // Esperamos
if (activo1) delay(tiempoEspera);
{ // Está encendido el semáforo 1, comprobamos el pulsador 2 // Pasamos a luz amarilla
int valor2 = digitalRead(PULSADOR2); digitalWrite(LEDVERDE2, LOW);
// Si hay un coche esperando, pulsador pulsado digitalWrite(LEDAMARILLO2, HIGH);
if (valor2 == HIGH) // Esperamos
{ // Encender semáforo 2 delay(tiempoCambio);
encenderSemaforo2(); // Pasamos a luz roja
// Semáforo 2 activo digitalWrite(LEDAMARILLO2, LOW);
digitalWrite(LEDROJO2, HIGH); digitalWrite(11, LOW);
// Encendemos semáforo 1 }
// Esperamos if (input=='5'){
delay(tiempoCambio); lum=true;
// Pasamos a luz amarilla d = Serial.read();
digitalWrite(LEDROJO1, LOW); delay(15);
digitalWrite(LEDVERDE1, HIGH); c = Serial.read();
} delay(15);
____________----- u = Serial.read();
Domotica con arduino luminosidad=(c*100)+(d*10)+c;
#include "DHT.h" }
#define DHTPIN 2 if (input=='6'){
#define DHTTYPE DHT11 tem=true;
DHT dht(DHTPIN, DHTTYPE); d = Serial.read();
int input=0; delay(15);
int time=0; c = Serial.read();
int h; umbral=(d*10)+c;
int t; }
int c; }
int d; if (lum==true){
int u; if (analogRead(A0)>luminosidad){
int umbral; digitalWrite(12, HIGH);
int luminosidad; }
boolean lum=true; else
boolean tem=true; {
void setup(){ digitalWrite(12, LOW);
pinMode(13, OUTPUT); }
pinMode(12, OUTPUT); }
pinMode(11, OUTPUT); if (time==5000){
Serial.begin(9600); time=0;
dht.begin(); h = dht.readHumidity();
} t = dht.readTemperature();
void loop(){
time++; Serial.println(t);
if (Serial.available()>0){ delay(25);
input = Serial.read(); Serial.println(h);
lum=false; delay(25);
tem=false; }
if (input=='1'){ if (tem==true){
digitalWrite(12, HIGH); if (t>umbral){
} digitalWrite(11, HIGH);
if (input=='2'){ }
digitalWrite(11, HIGH); else
} {
if (input=='3'){ digitalWrite(11, LOW);
digitalWrite(12, LOW); }
} }
if (input=='4'){ }
_______----- Zigbee vs Bluetooh -> se puede conectar mayor cantidad de nodos en zigbee, zigbee
tiene menor consumo eléctrico, se queda la mayor parte del tiempo dormido; zigbee
(F)Una placa arduino tiene entradas analógica puras de 0 a 5v. velocidad de hasta 250 Kbit y hasta 3000 Kbs
(V)En las placas arduino es posible fijar la reducción del commutador
(F)El LSB es independiente del número de bits
Desventajas de usar reg port: el código es mas difícil de depurar y mantener, es mas
(F)El voltaje de alimentación no se puede mesclar con con voltaje de referencia fácil causar mal funcionamiento
(V)para disminuir el LSB debe reducir el voltaje de referencia
(F)El ciclo de servicio de la señal de salida PWMes constante Ventajas cambiar los pines de estrado muy rápido, configurar muchos pines
(F)LA salida PWM puede realizarse sobre cualquier ping analógico exactamente al mismo tiempo, código mas pequeño en memoria
(F)La salida analógica es una señal que entrega con voltaje
(V)Una entrada analógica se puede expresar como entrda/salida digital DDR: determina si el pin es ent. O sal., PORT: controla si el pin esta eh HIGH o LOW,
(F)La dirección EEPROM a leer o escribir se guarda en ún único registro PIN: permite leer estado de pin que se configuro como ent usando pinMode; DDR y
(F)Los pines de control del LCD (RsEnRw) se conecta a alas entradas analógicas PORT pueden ser escritos y leidos PIN solo tiene tres puertos de reg PORT: B(pines
(V)El manejo de una pantalla LCD se puede ejecutar a través de dos pines.
(F)Las líneas SDA y SCL necesitan estar conectadas a resistencia PULL DOWN digitales de 8 a 13), C(ent analógicas)y D(pines digitales de 0 a 7 ) IEEE 802.15.4: es un
(V)Con I2C se puede lograr una comunicación bidireccional. estándar que define el nivel físico y el control de acceso al medio de redes inalámbricas
(F)Con I2C la velocidad mas común es de 100 kbytes/seg de área personal con tasas bajas de transmisión de datos(low-rate-wireless personal
(V)La comunicación entre arduino y una memoria EEPRON externo se raliza área network, LR- WPAN)
(V)El manejo del teclado se maneja por medio de una interrupción
(F)El manejo del borrado en una EEPRON es indeterminado Aumentar corriente que bota Arduino; configurar transistor base emisor y conectarlo a
(V)El proceso de una escritura en una es un proceso lento pues tarda uno 3.3 seg
(F)Con una placa arduino se puede utilizar el total de memoria de proceso arduino
(V)El boot loader viene grabado en la memoria del programa
(F)La placa arduino incorpora solo un microcontrolador
(V)Para ampliar la funcionalidad de un aplaca arduino puedo emplear
(V)En la IDE para arduino puedo compilar sin subir el archivo
(F)la sección de void setup se ejecuta de manera indefenida
(V)El boot loader constituye el firmware del microcontrolador
(F)En la IDE para arduino no se puede compilar sin subir el archivo
(F)La sección void Loop se ejecuta de un asola vez
(V)La placa arduino incorpora por lo menos dos microcontroladores
(V)una placa arduino tiene entradas analógicas puras de 0 a 5v
(V)los shields son modulos que agregan mas funciones al

El GSM(global system for mobile communication) es un sistema estándar de telefonía

móvil digital que le permite a las personas conectarse atravez de su teléfono a su
compañía y realizar distintas funciones, por su velocidad de transmisión es
considerado de segunda generación (2G)

El GPRS (general packet radio service) (servicio general de paquetes via radio) surgio
basado en esl sitema GSM pero como generación 2.5 ya que a diferencia de este que
solo transmite audio, el GRPS tiene la capacidad de trasmitir paquetes de datos
multimedia a una mayor velocidad GPRS sigue siendo utilizado en aquellos lugares
donde la tecnología 3G y 4G aun no ha sido desarrollado toalmente