ARDUINO UNO

Arduino es una plataforma de creación de electrónica de código abierto, la cual está

basada en hardware y software libre, flexible y fácil de utilizar para los creadores y
desarrolladores.

El hardware libre son los dispositivos cuyas especificaciones y diagramas son de

acceso público, de manera que cualquiera puede replicarlos. Esto quiere decir que
Arduino ofrece las bases para que cualquier otra persona o empresa pueda crear
sus propias placas, pudiendo ser diferentes entre ellas pero igualmente funcionales
al partir de la misma base.
El software libre son los programas informáticos cuyo código es accesible por
cualquiera para que quien quiera pueda utilizarlo y modificarlo. Arduino ofrece la
plataforma Arduino IDE (Entorno de Desarrollo Integrado), que es un entorno de
programación con el que cualquiera puede crear aplicaciones para las placas
Arduino, de manera que se les puede dar todo tipo de utilidades.
El Arduino es una placa basada en unos microcontroladores que son circuitos
integrados en los que se pueden grabar instrucciones, las cuales las escribes con
el lenguaje de programación que puedes utilizar en el entorno Arduino. Estas
instrucciones permiten crear programas que interactúan con los circuitos de la placa.
El microcontrolador de Arduino posee lo que se llama una interfaz de entrada, que
es una conexión en la que podemos conectar en la placa diferentes tipos de
periféricos. La información de estos periféricos que conectes se trasladará al
microcontrolador, el cual se encargará de procesar los datos que le lleguen a través
de ellos.
También cuenta con una interfaz de salida, que es la que se encarga de llevar la
información que se ha procesado en el Arduino a otros periféricos. Estos periféricos
pueden ser pantallas o altavoces en los que reproducir los datos procesados, pero
también pueden ser otras placas o controladores.
Esencialmente la placa Arduino Uno es una placa electrónica basada en el chip de
Atmel ATmega328 que es un microcontrolador más utilizado por Arduino(observe la
figura 1), tiene 14 pines digitales de entrada / salida.
Los componentes principales que constituyen el Arduino uno son los siguientes:
 Un tablero de pan
 Cable de 22 AWG
 7805 regulador de tensión
 2 LEDs
 2 resistencias de 220 ohmios
 Resistencia de 1 10k Ohm
 2 condensadores de 10 uF
 Cristal de reloj de 16 MHz
 2 condensadores de 22 pF
 pequeño botón momentáneo normalmente abierto ("apagado"), es decir,
Omron tipo B3F

El esquema de funcionamiento del Arduino uno se presenta a continuación:

SENSOR ULTRASÓNICO HC-SR04
El sensor HC-SR04 es un módulo que incorpora un par de transductores de
ultrasonido que se utilizan de manera conjunta para determinar la distancia del
sensor con un objeto colocado enfrente de este. Un transductor emite una “ráfaga”
de ultrasonido y el otro capta el rebote de dicha onda. El tiempo que tarda la onda
sonora en ir y regresar a un objeto puede utilizarse para conocer la distancia que
existe entre el origen del sonido y el objeto.
El HC-SR04 es un sensor que funciona a través de la medición del pulso de echo.
Este tipo de sensores poseen un pin de disparo y otro de eco, algunos incluso
combinan ambas funcionalidades en un solo pin. El microcontrolador que desea
realizar una medición debe medir el tiempo en alto de un pulso digital.
Las especificaciones obtenidas en la hoja de datos se basan principalmente en el
alcance del módulo ultrasónico se muestran a continuación:
Potencia suministrada de 5V DC
Ángulo efectivo < 15°
Distancia de alcance 2cm-500cm
Resolución de 0.3 cm
interfaz del sensor HC-SR04 y arduino se logra mediante 2 pines digitales: el pin de
disparo (trigger) y eco (echo). La función de cada uno de estos pines es la siguiente:
 El pin trigger recibe un pulso de habilitación de parte del microcontrolador,
mediante el cual se le indica al módulo que comience a realizar la medición
de distancia.
 En el pin echo el sensor devuelve al microcontrolador un puso cuyo ancho
es proporcional al tiempo que tarda el sonido en viajar del transductor al
obstáculo y luego de vuelta al módulo.

El HC-SR04 genera un pulso en el pin marcado como “echo” cuya duración es

proporcional a la distancia medida por el sensor.
El funcionamiento del sensor es el siguiente: el emisor piezoeléctrico emite 8 pulsos
de ultrasonido(40KHz) luego de recibir la orden en el pin TRIG, las ondas de sonido
viajan en el aire y rebotan al encontrar un objeto, el sonido de rebote es detectado
por el receptor piezoeléctrico, luego el pin ECHO cambia a Alto (5V) por un tiempo
igual al que demoró la onda desde que fue emitida hasta que fue detectada, el
tiempo del pulso ECO es medido por el microcontrolador y así se puede calcular la
distancia al objeto. El funcionamiento del sensor no se ve afectado por la luz solar
o material de color negro (aunque los materiales blandos acústicamente como tela
o lana pueden llegar a ser difíciles de detectar).
Nos entrega tiempo, como dijimos al comienzo el sensor hc-sr04 cuenta el tiempo
que transcurre entre la emisión y la recepción de la señal ultrasónica, claramente
podemos deducir que el tiempo es dependiente de la distancia, la señal tardara más
en ir y volver si el objeto este lejos que si está cerca.

Desarrollo del proyecto

1) La selección de los componentes debe cumplir con los objetivos del proyecto, proponer un
prototipo TCAS I, atreves de los siguientes componentes:
a) Arduino UNO: la tarjeta Arduino nos permite programar el sistema para poder controlar
los componentes que se usaran.
 b) HC-SR04: Sensor ultrasónico nos permite detectar obstáculos a cierta distancia, para
poder señalar obstáculos.
c) SG-90: Servo motor que nos permite ampliar el alcance del sensor ultrasónico para
detectar objetos en un rango más amplio.
d) Computadora: para poder representar la pantalla del radar.
e) Buzzer: Alerta de sonido para cabina.
f) LEDS: Simular la alerta visual.
g) Jumpers: permite realizar las conexiones.
h) LCD 16x2: permite visualizar los datos como ángulo y distancia donde se detecta el objeto.
i) Protobord: Realizar la alimentación del proyecto.
2) Dar una propuesta de conexiones, para esto se simulo en TinkerCAD.

3) Programar el Arduino UNO.

#include <Servo.h>
#include <LiquidCrystal.h>
// Defines Tirg and Echo pins of the Ultrasonic Sensor
LiquidCrystal lcd(7, 6, 5, 4, 3, 2); // Creates an LCD object. Parameters: (rs, enable, d4, d5, d6,
d7)
const int trigPin = 9; //Pin of the ULtrasonic sensor
const int echoPin = 10;
const int moteur = 11;
const int buzzer = 12;
const int ledPin1 = 14;
const int ledPin2 = 15;
float distanceCm, DistanceSec,duration;
// Variables for the duration and the distance
int distancei;
int calculateDistance(){ // Function for calculating the distance measured by the Ultrasonic
sensor

digitalWrite(trigPin, LOW);
 delayMicroseconds(2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH); // Reads the echoPin, returns the sound wave travel time
in microseconds
distancei= duration*0.034/2;
return distancei;
}
Servo myServo; // Creates a servo object for controlling the servo motor
void setup()
{
pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input
lcd.begin(16,2); // Initialiser l'interface de Lcd avec leurs Dimensions
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(buzzer, OUTPUT);
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
DistanceSec=20;
Serial.begin(9600);
myServo.attach(moteur); // Defines on which pin is the servo motor attached
}
void loop()
{
// rotates the servo motor from 15 to 165 degrees
for(int i=15;i<=165;i++)
{
myServo.write(i);
delay(30);
distancei = calculateDistance();// Calls a function for calculating the distance measured by the
Ultrasonic sensor for each degree
Serial.print(i); // Sends the current degree into the Serial Port
Serial.print(","); // Sends addition character right next to the previous value needed later in
the Processing IDE for indexing
Serial.print(distancei); // Sends the distance value into the Serial Port
Serial.print("."); // Sends addition character right next to the previous value needed later in
the Processing IDE for indexing
if (distancei <= DistanceSec)
{
if(distancei <= DistanceSec/2)
{
tone(buzzer, 10); // Send 1KHz sound signal...
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, HIGH);
delay(700);
noTone(buzzer); // Stop sound...
lcd.setCursor(0,0); // positionner le cursor a 0,0
lcd.print("Distance: "); // Printe "Distance" sur LCD
lcd.print(distancei); // Printe la valeur Obtenue sur LCD
lcd.print(" cm "); // Printe l'unité sur LCD
delay(10);
lcd.setCursor(0,1);
lcd.print("Angle : ");
lcd.print(i);
lcd.print(" deg ");
delay(2000);
}
else
{
digitalWrite(buzzer, HIGH);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin1, HIGH);
delay(100);
digitalWrite(buzzer, LOW);
lcd.setCursor(0,0); // positionner le cursor a 0,0
lcd.print("Distance: "); // Printe "Distance" sur LCD
lcd.print(distancei); // Printe la valeur Obtenue sur LCD
lcd.print(" cm "); // Printe l'unité sur LCD
delay(10);
lcd.setCursor(0,1);
lcd.print("Angle : ");
lcd.print(i);
lcd.print(" deg ");
delay(2000);
}
}
else{
digitalWrite(buzzer, LOW);
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
}
lcd.setCursor(0,0); // positionner le cursor a 0,0
lcd.print("Distance: "); // Printe "Distance" sur LCD
lcd.print(distancei); // Printe la valeur Obtenue sur LCD
lcd.print(" cm "); // Printe l'unité sur LCD
delay(10);
lcd.setCursor(0,1);
lcd.print("Angle : ");
lcd.print(i);
lcd.print(" deg ");
delay(80);
}
// Repeats the previous lines from 165 to 15 degrees
for(int i=165;i>15;i--)
{
myServo.write(i);
delay(30);
distancei = calculateDistance();
Serial.print(i);
Serial.print(",");
Serial.print(distancei);
Serial.print(".");

if (distancei <= DistanceSec){

if(distancei <= DistanceSec/2)
{
tone(buzzer, 10); // Send 1KHz sound signal...
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, HIGH);
delay(700);
noTone(buzzer); // Stop sound...
lcd.setCursor(0,0); // positionner le cursor a 0,0
lcd.print("Distance: "); // Printe "Distance" sur LCD
lcd.print(distancei); // Printe la valeur Obtenue sur LCD
lcd.print(" cm "); // Print in the LCD
delay(10);
lcd.setCursor(0,1);
lcd.print("Angle : ");
lcd.print(i);
lcd.print(" deg ");
delay(2000);
}
else
{
digitalWrite(buzzer, HIGH);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin1, HIGH);
delay(100);
digitalWrite(buzzer, LOW);
 lcd.setCursor(0,0); // position the cursor in 0,0
lcd.print("Distance: "); // Print "Distance" en LCD
lcd.print(distancei); // Print the value in LCD
lcd.print(" cm "); // Print in the LCD
delay(10);
lcd.setCursor(0,1);
lcd.print("Angle : ");
lcd.print(i);
lcd.print(" deg ");
delay(2000);
}
}
else
{
digitalWrite(buzzer, LOW);
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
}
lcd.setCursor(0,0); //
lcd.print("Distance: "); //
lcd.print(distancei); //
lcd.print(" cm ");
delay(10);
lcd.setCursor(0,1);
lcd.print("Angle : ");
lcd.print(i);
lcd.print(" deg ");
delay(80);
}
}
4) Programar la interfaz
import processing.serial.*; // imports library for serial communication
import java.awt.event.KeyEvent; // imports library for reading the data from the serial port
import java.io.IOException;
Serial myPort; // defines Object Serial
// defubes variables
String angle="";
String distance="";
String data="";
String noObject;
float pixsDistance;
int iAngle, iDistance;
int index1=0;
int index2=0;
PFont orcFont;
void setup() {

size (1920, 1080); // ***CHANGE THIS TO YOUR SCREEN RESOLUTION***

smooth();
myPort = new Serial(this,"COM7", 9600); // starts the serial communication
myPort.bufferUntil('.'); // reads the data from the serial port up to the character '.'. So
actually it reads this: angle,distance.
orcFont = loadFont("OCRAExtended-30.vlw");
}
void draw() {

fill(98,245,31);
textFont(orcFont);
// simulating motion blur and slow fade of the moving line
noStroke();
fill(0,4);
rect(0, 0, width, height-height*0.065);

fill(98,245,31); // green color

// calls the functions for drawing the radar
drawRadar();
drawLine();
drawObject();
drawText();
}
void serialEvent (Serial myPort) { // starts reading data from the Serial Port
// reads the data from the Serial Port up to the character '.' and puts it into the String variable
"data".
data = myPort.readStringUntil('.');
data = data.substring(0,data.length()-1);

index1 = data.indexOf(","); // find the character ',' and puts it into the variable "index1"
angle= data.substring(0, index1); // read the data from position "0" to position of the variable
index1 or thats the value of the angle the Arduino Board sent into the Serial Port
distance= data.substring(index1+1, data.length()); // read the data from position "index1" to
the end of the data pr thats the value of the distance

// converts the String variables into Integer

iAngle = int(angle);
iDistance = int(distance);
}
void drawRadar() {
pushMatrix();
 translate(width/2,height-height*0.074); // moves the starting coordinats to new location
noFill();
strokeWeight(2);
stroke(98,245,31);
// draws the arc lines
arc(0,0,(width-width*0.0625),(width-width*0.0625),PI,TWO_PI);
arc(0,0,(width-width*0.27),(width-width*0.27),PI,TWO_PI);
arc(0,0,(width-width*0.479),(width-width*0.479),PI,TWO_PI);
arc(0,0,(width-width*0.687),(width-width*0.687),PI,TWO_PI);
// draws the angle lines
line(-width/2,0,width/2,0);
line(0,0,(-width/2)*cos(radians(30)),(-width/2)*sin(radians(30)));
line(0,0,(-width/2)*cos(radians(60)),(-width/2)*sin(radians(60)));
line(0,0,(-width/2)*cos(radians(90)),(-width/2)*sin(radians(90)));
line(0,0,(-width/2)*cos(radians(120)),(-width/2)*sin(radians(120)));
line(0,0,(-width/2)*cos(radians(150)),(-width/2)*sin(radians(150)));
line((-width/2)*cos(radians(30)),0,width/2,0);
popMatrix();
}
void drawObject() {
pushMatrix();
translate(width/2,height-height*0.074); // moves the starting coordinats to new location
strokeWeight(9);
stroke(255,10,10); // red color
pixsDistance = iDistance*((height-height*0.1666)*0.025); // covers the distance from the
sensor from cm to pixels
// limiting the range to 40 cms
if(iDistance<40){
// draws the object according to the angle and the distance
line(pixsDistance*cos(radians(iAngle)),-pixsDistance*sin(radians(iAngle)),(width-
width*0.505)*cos(radians(iAngle)),-(width-width*0.505)*sin(radians(iAngle)));
}
popMatrix();
}
void drawLine() {
pushMatrix();
strokeWeight(9);
stroke(30,250,60);
translate(width/2,height-height*0.074); // moves the starting coordinats to new location
line(0,0,(height-height*0.12)*cos(radians(iAngle)),-(height-height*0.12)*sin(radians(iAngle)));
// draws the line according to the angle
popMatrix();
}
void drawText() { // draws the texts on the screen
 pushMatrix();
if(iDistance>40) {
noObject = "Out of Range";
}
else {
noObject = "In Range";
}
fill(0,0,0);
noStroke();
rect(0, height-height*0.0648, width, height);
fill(98,245,31);
textSize(25);

text("10cm",width-width*0.3854,height-height*0.0833);
text("20cm",width-width*0.281,height-height*0.0833);
text("30cm",width-width*0.177,height-height*0.0833);
text("40cm",width-width*0.0729,height-height*0.0833);
textSize(40);
text("Object: " + noObject, width-width*0.875, height-height*0.0277);
text("Angle: " + iAngle +" °", width-width*0.48, height-height*0.0277);
text("Distance: ", width-width*0.26, height-height*0.0277);
if(iDistance<40) {
text(" " + iDistance +" cm", width-width*0.225, height-height*0.0277);
}
textSize(25);
fill(98,245,60);
translate((width-width*0.4994)+width/2*cos(radians(30)),(height-height*0.0907)-
width/2*sin(radians(30)));
rotate(-radians(-60));
text("30°",0,0);
resetMatrix();
translate((width-width*0.503)+width/2*cos(radians(60)),(height-height*0.0888)-
width/2*sin(radians(60)));
rotate(-radians(-30));
text("60°",0,0);
resetMatrix();
translate((width-width*0.507)+width/2*cos(radians(90)),(height-height*0.0833)-
width/2*sin(radians(90)));
rotate(radians(0));
text("90°",0,0);
resetMatrix();
translate(width-width*0.513+width/2*cos(radians(120)),(height-height*0.07129)-
width/2*sin(radians(120)));
 rotate(radians(-30));
text("120°",0,0);
resetMatrix();
translate((width-width*0.5104)+width/2*cos(radians(150)),(height-height*0.0574)-
width/2*sin(radians(150)));
rotate(radians(-60));
text("150°",0,0);
popMatrix();
}

Presupuesto
HC-SR04 67
SG-90 49
Buzzer 5
LEDs 3
Protobord 150
Arduino UNO 159
LCD 16x2 49
Jumpers 32