Sensor Ultrasónico
Practica Final.. :)



#include <Servo.h>

const int trigger = 12;
const int echo = 11;
float dist, res;
Servo sd;
Servo si;

int led1 = 7;
int led2 = 6;
int led3 = 5;
int led4 = 4;

void bargraph (int led1, int led2, int led3, int led4)// Función bargraph
{
  digitalWrite (7,led1);
  digitalWrite (6,led2);
  digitalWrite (5,led3);
  digitalWrite (4,led4);
}

void setup(){
  Serial.begin(9600);
  pinMode(trigger, OUTPUT);
  pinMode(echo, INPUT);
}

void loop(){

  digitalWrite(trigger, LOW);
  delayMicroseconds(5);
  digitalWrite(trigger, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigger, LOW);

  //Adquirimos los datos y convertimos la media a cm
  dist = pulseIn(echo, HIGH); //Este resultado esta en microsegundos
  //Cuando la lectura del pin sea HIGH medira el tiempo que transcurre hasta que sea LOW en useg

  dist = dist/58; //Se hace la conversion a centimetros
  //Si queremos convertir a pulgadas se divide entre 148

  Serial.print("Distancia = "); //Imprimimos en la terminal un texto "Distancia = "
  Serial.print(dist); //Imprimimos en la terminal el valor de la distancia
  Serial.print("cm"); //Imprimimos en la terminal un texto "cm"
  Serial.write(10); //Enviamos en codigo ascii de "Nueva linea - salto de linea"

  if(dist >= 30){
    sd.attach(9);
    si.attach(10);
  
    sd.write(90);
    si.write(180);
  
    bargraph(0,1,1,0);
  }
 else if(dist <= 30){
    sd.attach(9);
    si.attach(10);
  
    sd.write(180);
    si.write(90);
  
    bargraph(1,0,0,1);
  }
 else{
    sd.detach();
   si.detach();
 }
}








Modelo: HC-SR04







/* ******************* Lectura de un sensor ultrasónico ***************************************
Modelo: HC-SR04
Rango: 2-400 cm
Precisión: 3mm
Ángulo de medición: 15°
PD: El área de los objetos no debe ser menor de 0.5m o se pueden obtener mediciones inexactas.
***********************************************************************************************
El siguiente programa es para medir la distancia entre el sensor ultrasónico y algún objeto
frente a él.
Metodología:
1. Se envía un pulso alto de una duración de 10 us por el pin Trigger
2. Se envía un pulso bajo después de transcurridos de los 10us.
3. Se hace la lectura del pulso de entrada en el pin Echo.
  3.1 dist = pulseIn(echo,HIGH); // este resultado está en microsegundos.
4. Para realizar la medición en cm, se aplica la fórmula de la lectura entre 58.
  4.1 dist = dist / 58 // Este resultado ya está en centímetros.
5. Se envía el resultado por la terminal para visualizar el resultado. */
h~
// DECLARACIÓN DE CONSTANTES Y VARIABLES
const int trigger=8;
const int echo=5;
float dist, res;


// CONFIGURACIÓN INICIAL
void setup(){
  Serial.begin(9600);
  pinMode(trigger,OUTPUT);
  pinMode(echo,INPUT);
}

// CICLO PRINCIPAL
void loop(){
  digitalWrite(trigger,LOW);
  delayMicroseconds(5);         // Inicialización del sensor para que se estabilice.

  digitalWrite(trigger,HIGH);   // Enviamos una señal activando la...
  delayMicroseconds(10);        // salida trigger durante 10 microsegundos
  digitalWrite(trigger,LOW);    // Desactivamos la señal del trigger para evitar interferencias.

// Adquirimos los datos y convertimos la medida a cm
  dist=pulseIn(echo,HIGH);      // Este resultado está en microsegundos.
                                // Cuando la lectura del pin sea HIGH medirá
                                // el tiempo que transcurre hasta que sea LOW en useg
  dist = dist/58;               // Se hace la conversión a centímetros
                                // Si quisieramos convertirlo a pulgadas, dividimos entre 148.
  Serial.print ("Distancia = ");// Imprimimos en la terminal un texto "Distancia = "                              
  Serial.print (dist);          // Imprimimos en la terminal el valor de la distancia
  Serial.print ("cm");          // Imprimimos en la terminal un texto "cm"
  Serial.write (10);            // Envíamos el código ascii de "Nueva línea - salto de línea"
  delay (200);                 // Esperamos un tiempo para visualizar el resultado.
}      
                     // Fin del programa.

//  PD: Abrir a terminal para visualizar los datos Ctrl + Shift + M
/* ******************* Lectura de un sensor ultrasónico ***************************************

Capture the flag







ESTRATEGIA 5. Programación del reto: Capture the flag
• En este momento, los alumnos deberán organizarse para llevar a cabo la programación del reto y el armado del
circuito para que éste funcione.
• ¿Qué se requiere hacer? Se deberá realizar una programación que realice lo siguiente:
• La conversión analógica – digital de las tres fotorresistencias.
• Se verificará, con ayuda del condicional IF – ELSE IF – ELSE el estado de las tres fotorresistencias al mismo
tiempo. Es necesario usar los operadores lógicos AND (&&) para comprobar varias condiciones al mismo
tiempo.
• Si se cumple el caso en el que la fotorresistencia de en medio recibe poca luz y las otras dos de los extremos
siguen recibiéndola, el robot avanzará hacia adelante. Y así con los demás casos que generan los giros a la
derecha, izquierda y el modo inmóvil, cuatro casos en total.
• Los equipos deberán organizarse para que puedan armar el circuito y programar al mismo tiempo, es decir, se
deberán de poner de acuerdo para delegar cada actividad y asimismo, ahorrar tiempo. El circuito a armar se
muestra en la siguiente diapositiva.


//  _ ___ _______     ___ ___ ___  ___ _   _ ___ _____ ___
// / |_  )__ /   \   / __|_ _| _ \/ __| | | |_ _|_   _/ __|
// | |/ / |_ \ |) | | (__ | ||   / (__| |_| || |  | | \__ \
// |_/___|___/___/   \___|___|_|_\\___|\___/|___| |_| |___/
//
// Práctica: CaptureTheFlag

//
// Made by Eduardo Rafael Ramírez Camarillo
// License: CC-BY-SA 3.0

/* ****************************** CAPTURE THE FLAG **********************************
************ Conversión analógica - digital del valor de TRES fotoresistencias *******
Se utilizan tres LDR para controlar el movimiento del Frogduino; si se tapa una fotorresistencia
se genera un movimiento diferente.

ADELANTE: --- LUZ --- OSCURO --- LUZ ---
DERECHA: --- OSCURO --- LUZ --- LUZ ---
IZQUIERDA: --- LUZ --- LUZ --- OSCURO ---
DETENIDO: --- LUZ --- LUZ --- LUZ ---
***************** IMPLEMENTACIÓN DE LA ESTRUCTURA IF ELSE *********************
***************** el resultado lo mostramos en la TERMINAL **************************
*/
#include <Servo.h>
int ldr1 = 0, ldr2 = 1, ldr3 = 2; // Pines donde conectaremos los LDR
int val1, val2, val3; // Variables para almacenar los resultados de las conversión Analog-Dig
int valMax = 200;

Servo ruedaIzq, ruedaDer;

void setup ()
{
  Serial.begin (9600); // Inicialización de la comunicación serial
  ruedaIzq.attach (13);
  ruedaDer.attach(10);
}

void loop ()
{
  val1 = analogRead (ldr1); // Conversión Analog-Dig y lo alamacena en "val1"
  val2 = analogRead (ldr2); // Conversión Analog-Dig y lo alamacena en "val2"
  val3 = analogRead (ldr3); // Conversión Analog-Dig y lo alamacena en "val3"

  // map (variable, val min, val max, adaptacion min, adaptacion max);

  Serial.print (val1);
  Serial.print("\t");       // Código de impresión de un tabulador horizontal
  Serial.print (val2);
  Serial.print("\t");
  Serial.println (val3);

  Serial.print ("AVANCE = ");

  if (val1 <= valMax && val2 >= valMax && val3 >= valMax)
  {
    Serial.println ("Izquierda");
    ruedaIzq.write (90);
    ruedaDer.write (0);
  }

  else if (val1 >= valMax && val2 <= valMax && val3 >= valMax)
  {
    Serial.println ("Adelante");
    ruedaIzq.write (180);
    ruedaDer.write (0);
  }

  else if (val1 >= valMax && val2 >= valMax && val3 <= valMax)
  {
    Serial.println ("Derecha");
    ruedaIzq.write (180);
    ruedaDer.write (90);
  }

  else
  {
    Serial.println ("Detenido");
    ruedaIzq.write (90);
    ruedaDer.write (90);
  }  
  delay (200); // Pausa para poder visualizar el resultado
} // FIN