// C++ code
/*
	Primer programa que envía mediante el Monitor Serial el valor de distancia
	leído por el sensor ultrasónico HC-SR04.  
*/

int TRIG = 10;			// trigger en pin 10
int ECO = 9;			// echo en pin 9
int LED = 3;			// LED en pin 3
int DURACION;
int DISTANCIA;

void setup()
{
  pinMode(TRIG, OUTPUT); 	// trigger como salida
  pinMode(ECO, INPUT);		// echo como entrada
  pinMode(LED, OUTPUT);		// LED como salida
  Serial.begin(9600);  		// inicializacion de comunicacion serial a 9600 bps

}

void loop()
{
  
  digitalWrite(TRIG, HIGH); 		// generacion del pulso a enviar
  delay(1);				// al pin conectado al trigger
  digitalWrite(TRIG, LOW);		// del sensor
  
  DURACION = pulseIn(ECO, HIGH);	// con funcion pulseIn se espera un pulso
  					// alto en Echo
  DISTANCIA = DURACION / 58.2;		// distancia medida en centimetros
  Serial.println(DISTANCIA);		// envio de valor de distancia por monitor serial
  delay(200);				// demora entre datos

   
}

// C++ code
/*
	Capitulo 5 de Arduino desde cero en Español
	Segundo programa que envía mediante el Monitor Serial el valor de distancia
	leído por el sensor ultrasónico HC-SR04 y enciende y apaga LED dentro del
	rango de 0 a 20 cms.

	Autor: bitwiseAr  

*/

int TRIG = 10;			// trigger en pin 10
int ECO = 9;			// echo en pin 9
int LED = 3;			// LED en pin 3
int DURACION;
int DISTANCIA;

void setup()
{
  pinMode(TRIG, OUTPUT); 	// trigger como salida
  pinMode(ECO, INPUT);		// echo como entrada
  pinMode(LED, OUTPUT);		// LED como salida
  Serial.begin(9600);  		// inicializacion de comunicacion serial a 9600 bps

}

void loop()
{
  
  digitalWrite(TRIG, HIGH); 		// generacion del pulso a enviar
  delay(1);				// al pin conectado al trigger
  digitalWrite(TRIG, LOW);		// del sensor
  
  DURACION = pulseIn(ECO, HIGH);	// con funcion pulseIn se espera un pulso
  					// alto en Echo
  DISTANCIA = DURACION / 58.2;		// distancia medida en centimetros
  Serial.println(DISTANCIA);		// envio de valor de distancia por monitor serial
  delay(200);				// demora entre datos

  if (DISTANCIA <= 20 && DISTANCIA >= 0){	// si distancia entre 0 y 20 cms.
    digitalWrite(LED, HIGH);			// enciende LED
    delay(DISTANCIA * 10);			// demora proporcional a la distancia
    digitalWrite(LED, LOW);			// apaga LED
    }
   
}

const int Trigger = 2;   //Pin digital 2 para el Trigger del sensor
const int Echo = 3;   //Pin digital 3 para el Echo del sensor

void setup() {
  Serial.begin(9600);//iniciailzamos la comunicación
  pinMode(Trigger, OUTPUT); //pin como salida
  pinMode(Echo, INPUT);  //pin como entrada
  digitalWrite(Trigger, LOW);//Inicializamos el pin con 0
}

void loop()
{

  long t; //timepo que demora en llegar el eco
  long d; //distancia en centimetros

  digitalWrite(Trigger, HIGH);
  delayMicroseconds(10);          //Enviamos un pulso de 10us
  digitalWrite(Trigger, LOW);
  
  t = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso
  d = t/59;             //escalamos el tiempo a una distancia en cm
  
  Serial.print("Distancia: ");
  Serial.print(d);      //Enviamos serialmente el valor de la distancia
  Serial.print("cm");
  Serial.println();
  delay(100);          //Hacemos una pausa de 100ms
}

/*
  Vamos a configurar las diferentes salidas de nuestro arduino lograr 
  diferentes colores utilizando la tecnica de adición
*/

//INICIO VARIABLES

int disparo = 4;
int echo = 2;

int ledTest = 13;

int ledRojo = 11;
int ledVerde = 10;
int ledAzul = 9;
int intensidad = 0;

//Inicio variables temporales

long tiempoPulso;
long tVal;


void setup() {
  //INICIO SETUP ENTRADAS / SALIDAS

  pinMode(ledTest, OUTPUT);
  pinMode(disparo, OUTPUT);
  pinMode(echo, INPUT);

  digitalWrite(disparo, LOW);
  analogWrite(ledRojo, 0);
  analogWrite(ledVerde, 0);
  analogWrite(ledAzul, 0);

  //Saludo Inicial
  digitalWrite(ledTest, HIGH);
  delay(500);
  digitalWrite(ledTest, LOW);
  delay(500);
  digitalWrite(ledTest, HIGH);
  delay(500);
  digitalWrite(ledTest, LOW);
  delay(500);
  digitalWrite(ledTest, HIGH);
  delay(500);
  digitalWrite(ledTest, LOW);
  delay(500);
}


void loop() {
  //Disparo de la señal.

  digitalWrite(disparo, HIGH); /* envío del pulso ultrasónico*/
  delayMicroseconds(10);
  digitalWrite(disparo, LOW);

  /*INICIO
     Medimos la longitud del puso entrante la utilizamos para medir el tiempo que transcurrido entre el envío  del pulso ultrasónico y cuando el sensor recibe el rebote,
     es decir: desde que el pin "echo" empieza a recibir el rebote, HIGH, hasta que deja de hacerlo, LOW, la longitud del pulso entrante.
     El resultado lo da en microsegundos
  */

  tiempoPulso = pulseIn(echo, HIGH);

  /*INICIO
    Ahora dependiendo del tiempo del pulso vamos a utilizar los leds RGB para señalar si el objeto se encuentra cerca o lejos.
    Cuando el objeto se encuentre a menos de 10cm mostraremos una luz roja (550µs segun las pruegas en el capitulo anterior)
    Cuando esté entre 20cm y 15cm una luz amarilla (860µs segun las pruegas en el capitulo anterior)
    Cuando está a entre 15cm y 20cm la luz verde (1140µs segun las pruegas en el capitulo anterior)
    Cuando esté mas lejos luz blanca proporcional a la distancia
  */
  if (tiempoPulso < 550) {
    analogWrite(ledRojo, 255);
    analogWrite(ledVerde, 0);
    analogWrite(ledAzul, 0);
  }
  else if ( tiempoPulso >= 550 &&  tiempoPulso < 860 ) {
    analogWrite(ledRojo, 255);
    analogWrite(ledVerde, 255);
    analogWrite(ledAzul, 0);
  }
  else if (tiempoPulso >= 860 && tiempoPulso < 1140) {
    analogWrite(ledRojo, 0);
    analogWrite(ledVerde, 255);
    analogWrite(ledAzul, 0);
  }
  else { 
    tVal = constrain(tiempoPulso, 1140, 5700); /* Constrain limita el valor obtenido en la variable (el primer parametro) a un valor entre 
                                               el 2° parametro (limite inferior, 1140 en este caso) y el 3° parametro (limite superiro 5700).
                                              Funciona de la siguiente forma:
                                              si tiempoPulso esta entre los limites, devuelve el mismo valor de tiempoPulso, 
                                              si es menor al limite inferior, reemplaza tiempoPulso por el limite inferior (1140 en este caso)
                                              si es superior al limite superior, reemplaza el valor de tiempoPulso por el limite superior (5700) */
    
    
    intensidad = map(tVal, 1140, 5700, 0, 255);  /*  map(X, inMin,inMax,outMin,outMax)   transforma el valor obtenido antes (tval), que 
                                              estaba entre 1140 y 5700 a un nuevo valor proporcional pero entre 0 y 255 que son los que
                                              puede utilizar analogWrite en los pines.*/   
    

    analogWrite(ledRojo, intensidad);          
    analogWrite(ledVerde, intensidad);
    analogWrite(ledAzul, intensidad);
  }

}

/* Funcionamiento básico de un microservo

**Desafío 1:
¿Cómo girar el servo 45 grados?
**Desafío 2:
¿Cómo girar el servo 120 grados?
**Desafío 3:
Generar un programa que cambie el nombre del servo 
y que gire de 45 grados a 120 grados 
en otro pin ¿Cuál podrías elegir?

Prof. Daniel Tedesco */



#include <Servo.h>

Servo servo;


void setup() {
servo.attach(9);
}

void loop() {
servo.write(0);
delay(2000);

servo.write(90);
delay(2000);
}

// C++ code
/*
	Capitulo 6 de Arduino desde cero en Español
	Primer programa que mueve el servomotor de 0 a 180 grados cada cinco segundos y
	se usa para determinar el valor practico del pulso minimo y maximo.  
*/

#include <Servo.h>  		// incluye libreria de Servo

Servo servo1;			// crea objeto

int PINSERVO = 2;		// pin 2 conectado a señal del servo
int PULSOMIN = 1000;		// pulso minimo en microsegundos
int PULSOMAX = 2000;		// pulso maximo en microsegundos


void setup()
{
  servo1.attach(PINSERVO, PULSOMIN, PULSOMAX);	// inicializacion de servo
}

void loop()
{
  servo1.write(0);		// ubica el servo a 0 grados
  delay(5000); 			// espera de 5 seg.
  servo1.write(180);		// ubica el servo a 180 grados
  delay(5000);			// espera de 5 seg.
}

// C++ code
/*
	Capitulo 6 de Arduino desde cero en Español
	Segundo programa que lee el valor del potenciometro conectado a entrada A0
	y lo convierte a valor de angulo para mover al servo hacia el mismo.  

*/

#include <Servo.h>  		// incluye libreria de Servo

Servo servo1;			// crea objeto

int PINSERVO = 2;		// pin 2 conectado a señal del servo
int PULSOMIN = 1000;		// pulso minimo en microsegundos
int PULSOMAX = 2000;		// pulso maximo en microsegundos
int VALORPOT;			// variable para almacenar valor leido en entrada A0
int ANGULO;			// valor de angulo a cargar en el servo

int POT = 0;			// potenciometro en entrada analogica A0

void setup()
{
  servo1.attach(PINSERVO, PULSOMIN, PULSOMAX);	// inicializacion de servo
// las entradas analogicas no requieren inicializacion
}

void loop()
{
  VALORPOT = analogRead(POT);			// lee valor de entrada A0
  ANGULO = map(VALORPOT, 0, 1023, 0, 180);	// con funcion map convierte rango de 0 a 1023
						// a rango de angulo de 0 a 180
  servo1.write(ANGULO);				// envia al servo el valor del angulo
  delay(20);					// demora para que el servo llegue a posicion
}

#include <Servo.h>
#define pin_servo 2
#define ledrojo 4
#define trigPin 13
#define echoPin 12
#define buzzer 9
#define frecuencia 1000
long duration;
long distance;
Servo myservo;

void setup()
{
  pinMode (pin_servo, OUTPUT);
  pinMode (ledrojo, OUTPUT);
  pinMode (trigPin, OUTPUT);
  pinMode (echoPin, INPUT);
  pinMode (buzzer, OUTPUT);
  myservo.attach(pin_servo);
}

void loop()
{
digitalWrite(trigPin, LOW);
  delay (0.002);
  digitalWrite(trigPin, HIGH);
  delay (0.01);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin,HIGH);
  distance = (duration / 2) / 29.1;
  if (distance <= 50) 
{
    
    digitalWrite(ledrojo,HIGH);
    tone(buzzer,frecuencia);
    delay (1000);
    noTone(buzzer);
    myservo.write(180);
    delay(15);
}
  else
{
    digitalWrite(ledrojo,LOW);
    myservo.write(0);
   }
    }

// SERVO //
#include <Servo.h>

Servo myservo;
Servo myservo2;

// POSICION //
#include "SHCSR04.h"

float distancia = 0;

SHCSR04 hcsr04;

void setup() {
  // Servo
  myservo.attach(9);
  myservo2.attach(10);
  // Serial
  Serial.begin(115200);

}

void loop() {
  distancia = hcsr04.read(4, 5);
  Serial.println(distancia);
  delay(100);

  if (distancia < 5) {
    myservo.write(50);
    myservo2.write(10);
    delay(500);
  } else {
    myservo.write(10);
    myservo2.write(50);
    delay(500);
  }

}

/*
  Vamos a configurar las diferentes salidas de nuestro arduino lograr 
  diferentes colores utilizando la tecnica de adición
*/

//INICIO VARIABLES

int disparo = 4;
int echo = 2;

int ledTest = 13;

int ledRojo = 11;
int ledVerde = 10;
int ledAzul = 9;
int intensidad = 0;

//Inicio variables temporales

long tiempoPulso;
long tVal;


void setup() {
  //INICIO SETUP ENTRADAS / SALIDAS

  pinMode(ledTest, OUTPUT);
  pinMode(disparo, OUTPUT);
  pinMode(echo, INPUT);

  digitalWrite(disparo, LOW);
  analogWrite(ledRojo, 0);
  analogWrite(ledVerde, 0);
  analogWrite(ledAzul, 0);

  //Saludo Inicial
  digitalWrite(ledTest, HIGH);
  delay(500);
  digitalWrite(ledTest, LOW);
  delay(500);
  digitalWrite(ledTest, HIGH);
  delay(500);
  digitalWrite(ledTest, LOW);
  delay(500);
  digitalWrite(ledTest, HIGH);
  delay(500);
  digitalWrite(ledTest, LOW);
  delay(500);
}


void loop() {
  //Disparo de la señal.

  digitalWrite(disparo, HIGH); /* envío del pulso ultrasónico*/
  delayMicroseconds(10);
  digitalWrite(disparo, LOW);

  /*INICIO
     Medimos la longitud del puso entrante la utilizamos para medir el tiempo que transcurrido entre el envío  del pulso ultrasónico y cuando el sensor recibe el rebote,
     es decir: desde que el pin "echo" empieza a recibir el rebote, HIGH, hasta que deja de hacerlo, LOW, la longitud del pulso entrante.
     El resultado lo da en microsegundos
  */

  tiempoPulso = pulseIn(echo, HIGH);

  /*INICIO
    Ahora dependiendo del tiempo del pulso vamos a utilizar los leds RGB para señalar si el objeto se encuentra cerca o lejos.
    Cuando el objeto se encuentre a menos de 10cm mostraremos una luz roja (550µs segun las pruegas en el capitulo anterior)
    Cuando esté entre 20cm y 15cm una luz amarilla (860µs segun las pruegas en el capitulo anterior)
    Cuando está a entre 15cm y 20cm la luz verde (1140µs segun las pruegas en el capitulo anterior)
    Cuando esté mas lejos luz blanca proporcional a la distancia
  */
  if (tiempoPulso < 550) {
    analogWrite(ledRojo, 255);
    analogWrite(ledVerde, 0);
    analogWrite(ledAzul, 0);
  }
  else if ( tiempoPulso >= 550 &&  tiempoPulso < 860 ) {
    analogWrite(ledRojo, 255);
    analogWrite(ledVerde, 255);
    analogWrite(ledAzul, 0);
  }
  else if (tiempoPulso >= 860 && tiempoPulso < 1140) {
    analogWrite(ledRojo, 0);
    analogWrite(ledVerde, 255);
    analogWrite(ledAzul, 0);
  }
  else { 
    tVal = constrain(tiempoPulso, 1140, 5700); /* Constrain limita el valor obtenido en la variable (el primer parametro) a un valor entre 
                                               el 2° parametro (limite inferior, 1140 en este caso) y el 3° parametro (limite superiro 5700).
                                              Funciona de la siguiente forma:
                                              si tiempoPulso esta entre los limites, devuelve el mismo valor de tiempoPulso, 
                                              si es menor al limite inferior, reemplaza tiempoPulso por el limite inferior (1140 en este caso)
                                              si es superior al limite superior, reemplaza el valor de tiempoPulso por el limite superior (5700) */
    
    
    intensidad = map(tVal, 1140, 5700, 0, 255);  /*  map(X, inMin,inMax,outMin,outMax)   transforma el valor obtenido antes (tval), que 
                                              estaba entre 1140 y 5700 a un nuevo valor proporcional pero entre 0 y 255 que son los que
                                              puede utilizar analogWrite en los pines.*/   
    

    analogWrite(ledRojo, intensidad);          
    analogWrite(ledVerde, intensidad);
    analogWrite(ledAzul, intensidad);
  }

}

#include <Servo.h>   //servo library
Servo servo;     
int trigPin = 5;    
int echoPin = 6;   
int servoPin = 7;
int led= 10;
long duration, dist, average;   
long aver[3];   //array for average


void setup() {       
    Serial.begin(9600);
    servo.attach(servoPin);  
    pinMode(trigPin, OUTPUT);  
    pinMode(echoPin, INPUT);  
    servo.write(0);         //close cap on power on
    delay(100);
    servo.detach(); 
} 

void measure() {  
 digitalWrite(10,HIGH);
digitalWrite(trigPin, LOW);
delayMicroseconds(5);
digitalWrite(trigPin, HIGH);
delayMicroseconds(15);
digitalWrite(trigPin, LOW);
pinMode(echoPin, INPUT);
duration = pulseIn(echoPin, HIGH);
dist = (duration/2) / 29.1;    //obtain distance
}
void loop() { 
  for (int i=0;i<=2;i++) {   //average distance
    measure();               
   aver[i]=dist;            
    delay(10);              //delay between measurements
  }
 dist=(aver[0]+aver[1]+aver[2])/3;    

if ( dist<50 ) {
//Change distance as per your need
 servo.attach(servoPin);
  delay(1);
 servo.write(0);  
 delay(3000);       
 servo.write(150);    
 delay(1000);
 servo.detach();      
}
Serial.print(dist);
}

#include <LiquidCrystal.h>
int rs = 12;
int e = 11;
int d4 = 5;
int d5 = 4;

int dTime = 500;
//LCD

int d6 = 3;
int d7 = 2;
int numero = 0;

LiquidCrystal lcd(rs, e, d4, d5, d6, d7);

//DHT11

#include <DHT.h>
#include <DHT_U.h>

#define Type DHT11
int dhtPin = 8;
DHT HT(dhtPin, Type);
int humidity;
float tempC;
float tempF;


void setup() {
  // put your setup code here, to run once:
  lcd.begin(16, 2);
  Serial.begin(9600);
  HT.begin();
}

void loop() {
  // put your main code here, to run repeatedly:
  humidity = HT.readHumidity();
  tempC = HT.readTemperature();
  //tempF = HT.readTemperature(true);
  Serial.print("Humedad Relativa: ");
  Serial.print(humidity);
  Serial.print("% / Temperatura: ");
  Serial.print(tempC);
  Serial.print("ºC / ");
  Serial.print(tempF);
  Serial.println("ºF");


  lcd.setCursor(0, 0);
  lcd.print("Humedad: ");
  lcd.print(humidity);
  lcd.print("%");

  lcd.setCursor(0, 1);
  lcd.print("Temp.: ");
  lcd.print(tempC);
  lcd.print("*C");

  delay(dTime);
  lcd.clear();
}

#include <SimpleDHT.h>                   // Data ---> D3 VCC ---> 3V3 GND ---> GND --->Pines de conexión
#include <ESP8266WiFi.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"
// WiFi parameters
#define WLAN_SSID       "Speedy-Fibra-"// coneccción del SSID de wi fi (preferentemente 2.4 Ghz)
#define WLAN_PASS       "Kaball0_L0c0" // Incluír la clave de wi fi
// Adafruit IO
#define AIO_SERVER      "io.adafruit.com"
#define AIO_SERVERPORT  1883
#define AIO_USERNAME    "profdanieltedesco" // usuario de Adafruit
#define AIO_KEY         "aio_umyQ26M2YPO3Zw2xafOB0P5Nl5B8" //Llave de Adafruit
WiFiClient client;
// Setup the MQTT client class by passing in the WiFi client and MQTT server and login details.
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);
Adafruit_MQTT_Publish temperatura = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/temperatura"); //Colocar el feed de temperatura
Adafruit_MQTT_Publish humedad = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/humedad"); // Colocar el feed de humedad

int pinDHT11 = 0;
SimpleDHT11 dht11(pinDHT11);
byte hum = 0;  //Stores humidity value
byte temp = 0; //Stores temperature value
void setup() {
  Serial.begin(115200);
  Serial.println(F("Adafruit IO Example"));
  // Connect to WiFi access point.
  Serial.println(); Serial.println();
  delay(10);
  Serial.print(F("Connecting to "));
  Serial.println(WLAN_SSID);
  WiFi.begin(WLAN_SSID, WLAN_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(F("."));
  }
  Serial.println();
  Serial.println(F("WiFi connected"));
  Serial.println(F("IP address: "));
  Serial.println(WiFi.localIP());

  // connect to adafruit io
  connect();

}

// connect to adafruit io via MQTT
void connect() {
  Serial.print(F("Connecting to Adafruit IO... "));
  int8_t ret;
  while ((ret = mqtt.connect()) != 0) {
    switch (ret) {
      case 1: Serial.println(F("Wrong protocol")); break;
      case 2: Serial.println(F("ID rejected")); break;
      case 3: Serial.println(F("Server unavail")); break;
      case 4: Serial.println(F("Bad user/pass")); break;
      case 5: Serial.println(F("Not authed")); break;
      case 6: Serial.println(F("Failed to subscribe")); break;
      default: Serial.println(F("Connection failed")); break;
    }

    if(ret >= 0)
      mqtt.disconnect();

    Serial.println(F("Retrying connection..."));
    delay(10000);
  }
  Serial.println(F("Adafruit IO Connected!"));
}

void loop() {
  // ping adafruit io a few times to make sure we remain connected
  if(! mqtt.ping(3)) {
    // reconnect to adafruit io
    if(! mqtt.connected())
      connect();
  }
  dht11.read(&temp, &hum, NULL);
  Serial.print((int)temp); Serial.print(" *C, "); 
  Serial.print((int)hum); Serial.println(" H");
  delay(5000);
   
   if (! temperatura.publish(temp)) {                     //Publish to Adafruit
      Serial.println(F("Failed"));
    } 
       if (! humedad.publish(hum)) {                     //Publish to Adafruit
      Serial.println(F("Failed"));
    }
    else {
      Serial.println(F("Sent!"));
    }
}

#define sensor A0 
int valor = 0;

void setup()
{
    Serial.begin(9600);
}
void loop()
{
    int valor = map(analogRead(sensor), 0, 1023, 100, 0);
    //se hace un mapeo de la lectura del sensor a porcentual
    Serial.print("Humedad: ");
    Serial.print(valor);
    Serial.println("%");
    delay(100);
}

/**
   Arduino Calculator

*/

#include <LiquidCrystal.h>
#include <Keypad.h>
#include <Servo.h>

/* Display */
LiquidCrystal lcd(12, 11, 10, 9, 8, 7);

/* Keypad setup */
const byte KEYPAD_ROWS = 4;
const byte KEYPAD_COLS = 4;
byte rowPins[KEYPAD_ROWS] = {5, 4, 3, 2};
byte colPins[KEYPAD_COLS] = {A3, A2, A1, A0};
char keys[KEYPAD_ROWS][KEYPAD_COLS] = {
  {'1', '2', '3', '+'},
  {'4', '5', '6', '-'},
  {'7', '8', '9', '*'},
  {'.', '0', '=', '/'}
};

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, KEYPAD_ROWS, KEYPAD_COLS);

uint64_t value = 0;

void showSpalshScreen() {
  lcd.print("GoodArduinoCode");
  lcd.setCursor(3, 1);
  String message = "Calculator";
  for (byte i = 0; i < message.length(); i++) {
    lcd.print(message[i]);
    delay(50);
  }
  delay(500);
}

void updateCursor() {
  if (millis() / 250 % 2 == 0 ) {
    lcd.cursor();
  } else {
    lcd.noCursor();
  }
}

void setup() {
  Serial.begin(115200);
  lcd.begin(16, 2);

  showSpalshScreen();
  lcd.clear();
  lcd.cursor();

  lcd.setCursor(1, 0);
}

char operation = 0;
String memory = "";
String current = "";
uint64_t currentDecimal;
bool decimalPoint = false;

double calculate(char operation, double left, double right) {
  switch (operation) {
    case '+': return left + right;
    case '-': return left - right;
    case '*': return left * right;
    case '/': return left / right;
  }
}

void processInput(char key) {
  if ('-' == key && current == "") {
    current = "-";
    lcd.print("-");
    return;
  }

  switch (key) {
    case '+':
    case '-':
    case '*':
    case '/':
      if (!operation) {
        memory = current;
        current = "";
      }
      operation = key;
      lcd.setCursor(0, 1);
      lcd.print(key);
      lcd.setCursor(current.length() + 1, 1);
      return;

    case '=':
      float leftNum = memory.toDouble();
      float rightNum = current.toDouble();
      memory = String(calculate(operation, leftNum, rightNum));
      current = "";
      lcd.clear();
      lcd.setCursor(1, 0);
      lcd.print(memory);
      lcd.setCursor(0, 1);
      lcd.print(operation);
      return;

  }

  if ('.' == key && current.indexOf('.') >= 0) {
    return;
  }

  if ('.' != key && current == "0") {
    current = String(key);
  } else if (key) {
    current += String(key);
  }

  lcd.print(key);
}

void loop() {
  updateCursor();

  char key = keypad.getKey();
  if (key) {
    processInput(key);
  }
}

#include <Servo.h>

// Variables para los ángulos de los servos y el retraso de velocidad
double Pan;
double Tilt;
double Retardovelocidad;

// Objetos Servo para los servos de pan y tilt
Servo servo_9;
Servo servo_10;

// Pines de los componentes
const int ledPin = 13; // Pin digital al que está conectado el LED
const int joystickButtonPin = 2; // Pin digital al que está conectado el botón del joystick

// Variables para el manejo del botón del joystick
bool ledState = LOW; // Estado actual del LED
bool lastButtonState = HIGH; // Último estado del botón
bool buttonPressed = false; // Indica si el botón ha sido presionado en la última lectura

void leer_joystick() {
    // Lee el valor del joystick para el control del servo de pan
    int panValue = map(analogRead(A0), 0, 1023, 0, 100);
    
    if (panValue < 25) {
        Pan = Pan - 1; // Mueve el servo de pan hacia la izquierda
    }

    if (panValue > 75) {
        Pan = Pan + 1; // Mueve el servo de pan hacia la derecha
    }

    // Lee el valor del joystick para el control del servo de tilt
    int tiltValue = map(analogRead(A1), 0, 1023, 0, 100);
    
    if (tiltValue < 25) {
        Tilt = Tilt - 1; // Mueve el servo de tilt hacia abajo
    }

    if (tiltValue > 75) {
        Tilt = Tilt + 1; // Mueve el servo de tilt hacia arriba
    }

    // Constrain asegura que los ángulos se mantengan dentro del rango permitido
    Pan = constrain(Pan, 0, 180);
    Tilt = constrain(Tilt, 0, 180);
}

void setup() {
    // Inicializa los servos y los pines
    servo_9.attach(9); // Servo de pan conectado al pin 9
    servo_10.attach(10); // Servo de tilt conectado al pin 10
    pinMode(A0, INPUT); // Configura el pin A0 como entrada
    pinMode(A1, INPUT); // Configura el pin A1 como entrada
    pinMode(ledPin, OUTPUT); // Configura el pin del LED como salida
    pinMode(joystickButtonPin, INPUT_PULLUP); // Configura el pin del botón del joystick como entrada con resistencia pull-up

    // Posición inicial de los servos
    Pan = 90; // Posición central del servo de pan
    Tilt = 90; // Posición central del servo de tilt
    Retardovelocidad = 50; // Velocidad de retardo en milisegundos

    // Asegura que el LED esté apagado al inicio
    digitalWrite(ledPin, LOW); // Apaga el LED
}

void loop() {
    leer_joystick(); // Lee los valores del joystick y actualiza los ángulos de los servos

    // Lee el estado actual del botón del joystick
    bool currentButtonState = digitalRead(joystickButtonPin);

    // Detecta el cambio en el estado del botón (de HIGH a LOW)
    if (lastButtonState == HIGH && currentButtonState == LOW) {
        // Si el botón se ha presionado, cambia el estado del LED
        ledState = !ledState;
        digitalWrite(ledPin, ledState); // Actualiza el LED con el nuevo estado
        buttonPressed = true; // Marca que el botón ha sido presionado
    } else if (currentButtonState == HIGH) {
        // Marca que el botón ha sido liberado
        buttonPressed = false;
    }

    // Actualiza el estado anterior del botón
    lastButtonState = currentButtonState;

    // Ajusta los servos a las nuevas posiciones
    servo_9.write(Pan);
    servo_10.write(Tilt);
    delay(Retardovelocidad); // Espera para controlar la velocidad de movimiento
}