Vous êtes sur la page 1sur 28

MATERIALES

1) Arduino UNO R3 con cable USB

2) Pantalla LCD 16x2

3) Sensor DS18B20

4) Protoboard

5) Potenciómetro

6) Resistencia de 4.7k

PROCEDIMIENTO

1) Lo primero que tenemos que hacer es conectar la pantalla LCD 16x2 con su respectivo
potenciómetro, lo estaremos conectando de esta manera:

2) Ahora conectaremos el sensor DS18B20, pero antes conoceremos acerca de este sensor.
El DS18B20 viene en diferentes presentaciones ya sea en encapsulado o en una sonda de
1m.
Como pueden ver el sensor tiene 3 pines: Vcc( ROJO-3), GND( negro-1) y señal
(AMARILLO-2), es por el cable amarillo donde la señal es enviada hacia el
microcontrolador a través de un protocolo bastante usado llamado OneWire (este protocolo
usa una librería); y es de vital importancia colocar un resistencia de aprox. 4.7k entre la
señal (cable amarillo) y el pin de Vcc ya que sin esta resistencia el sensor no funcionará.
También tenemos que tener en cuenta que el rango de medición de este sensor está entre los
-55ºC y los 150ºC fácilmente sumergible en cualquier líquido.

Pasemos ahora hacer la conexión del sensor al Arduino junto a la pantalla LCD.
3) Ahora pasaremos a la programación, para eso lo primero que tenemos que hacer es
descargar la librería OneWire y DallasTemperature, ambas librerías servirán para
establecer el protocolo de comunicación (OneWire) y para el reconocimiento del sensor
(DallasTemperature)

CODIGO

#include <OneWire.h> //Se importan las librerías

#include <DallasTemperature.h>

#include <LiquidCrystal.h>

#define Pin 3 //Se declara el pin donde se conectará la DATA

LiquidCrystal lcd(12, 11, 7, 6, 5, 4);

OneWire ourWire(Pin); //Se establece el pin declarado como bus para la comunicación OneWire

DallasTemperature sensors(&ourWire); //Se instancia la librería DallasTemperature

void setup() {

lcd.begin(16, 2);

sensors.begin(); //Se inician los sensores

}
void loop()

sensors.requestTemperatures(); //Prepara el sensor para la lectura

lcd.setCursor(0, 1);

lcd.print(sensors.getTempCByIndex(0)); //Se lee e imprime la temperatura en grados Celsius

lcd.print("ºC");

lcd.setCursor(1, 1);

lcd.print(sensors.getTempFByIndex(0)); //Se lee e imprime la temperatura en grados Fahrenheit

lcd.println("F");

delay(1000); //Se provoca un lapso de 1 segundo antes de la próxima lectura

}
CONTRASEÑA CON MATRIZ 4X4 Y LCD

PROGRAMA

#include <Password.h> //Incluimos la libreria Password

#include <Keypad.h> //Incluimos la libreria Keypad

#include <LiquidCrystal.h> //Incluimos la libreria LiquidCrystal

Password password = Password("1A2B3"); //Definimos el Password

int dlugosc = 5; //Largo del Password

LiquidCrystal lcd(A0, A1, A2, A3, A4, A5); //Definimos los pines del LCD

int buzzer = 10; //Creamos las Variables de salida

int ledRed = 11;

int ledGreen = 12;


int ilosc; //Numero de Clicks

const byte ROWS = 4; // Cuatro Filas

const byte COLS = 4; // Cuatro Columnas

// Definimos el Keymap

char keys[ROWS][COLS] = {

{'1','2','3','A'},

{'4','5','6','B'},

{'7','8','9','C'},

{'*','0','#','D'}

};

byte rowPins[ROWS] = { 9,8,7,6 };// Conectar los keypads ROW1, ROW2, ROW3 y ROW4 a esos
Pines de Arduino.

byte colPins[COLS] = { 5,4,3,2, };// Conectar los keypads COL1, COL2, COL3 y COL4 a esos Pines de
Arduino.

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup()

Serial.begin(9600);

keypad.addEventListener(keypadEvent);

pinMode(ledRed, OUTPUT);

pinMode(ledGreen, OUTPUT);

pinMode(buzzer, OUTPUT);

digitalWrite(ledRed, HIGH);
digitalWrite(ledGreen, LOW);

lcd.begin(16, 2);

lcd.setCursor(0,0);

lcd.print(" *Bienvenido*");

lcd.setCursor(0,1);

lcd.print("PIN SECRETO");

void loop()

keypad.getKey();

void keypadEvent(KeypadEvent eKey)

switch (keypad.getState())

case PRESSED:

int i;

for( i = 1; i <= 1; i++ )

digitalWrite(buzzer, HIGH);

delay(200);

digitalWrite(buzzer, LOW);

delay(100);

}
Serial.print("Pressed: ");

Serial.println(eKey);

switch (eKey)

/*

case '#':

break;

case '*':

break;

*/

default:

ilosc=ilosc+1;

password.append(eKey);

//Serial.println(ilosc);

if(ilosc == 1)

lcd.clear();

lcd.setCursor(1,0);

lcd.print(" < PIN >");

lcd.setCursor(0,1);

lcd.print("*_");

if(ilosc == 2)

{
lcd.clear();

lcd.setCursor(1,0);

lcd.print(" < PIN >");

lcd.setCursor(0,1);

lcd.print("**_");

if(ilosc == 3)

lcd.clear();

lcd.setCursor(1,0);

lcd.print(" < PIN >");

lcd.setCursor(0,1);

lcd.print("***_");

if(ilosc == 4)

lcd.clear();

lcd.setCursor(1,0);

lcd.print(" < PIN >");

lcd.setCursor(0,1);

lcd.print("****_");

if(ilosc == 5)

lcd.clear();

lcd.setCursor(1,0);

lcd.print(" < PIN >");

lcd.setCursor(0,1);

lcd.print("*****_");
}

if(ilosc == 6)

lcd.clear();

lcd.setCursor(1,0);

lcd.print(" < PIN >");

lcd.setCursor(0,1);

lcd.print("******_");

if(ilosc == 7)

lcd.clear();

lcd.setCursor(1,0);

lcd.print(" < PIN >");

lcd.setCursor(0,1);

lcd.print("*******_");

if(ilosc == 8)

lcd.clear();

lcd.setCursor(1,0);

lcd.print(" < PIN >");

lcd.setCursor(0,1);

lcd.print("********");

if(ilosc == dlugosc)

delay(250);
checkPassword();

ilosc = 0;

void checkPassword()

if (password.evaluate())

int i;

for( i = 1; i <= 3; i++ )

digitalWrite(buzzer, HIGH);

delay(120);

digitalWrite(buzzer, LOW);

delay(70);

ilosc = 0;

password.reset();

Serial.println("Correcto");

digitalWrite(ledRed, LOW);

digitalWrite(ledGreen, HIGH);

lcd.clear();

lcd.setCursor(0,1);

lcd.print("<<PIN CORRECTO>>");
delay(2000);

digitalWrite(ledGreen, LOW);

digitalWrite(ledRed, HIGH);

lcd.clear();

lcd.setCursor(0,0);

lcd.print(" *Bienvenido*");

lcd.setCursor(0,1);

lcd.print("PIN SECRETO");

else

int i;

for( i = 1; i <= 1; i++ )

digitalWrite(buzzer, HIGH);

delay(300);

digitalWrite(buzzer, LOW);

delay(100);

ilosc = 0;

password.reset();

Serial.println("Error");

digitalWrite(ledGreen, LOW);

digitalWrite(ledRed, HIGH);
lcd.clear();

lcd.setCursor(0,1);

lcd.print("<<PIN ERRONEO>>");

delay(2000);

lcd.clear();

lcd.setCursor(0,0);

lcd.print(" *Bienvenido*");

lcd.setCursor(0,1);

lcd.print("PIN SECRETO ");

}
MOTOR A PASOS

Funcionamiento

Cuando circula corriente por una o más bobinas del estator se crea un campo magnético
creando los polos Norte-Sur. Luego el rotor se equilibrará magnéticamente orientando sus
polos Norte-Sur hacia los polos Sur-Norte del estator. Cuando el estator vuelva a cambiar la
orientación de sus polos a través de un nuevo impulso recibido hacia sus bobinas, el rotor
volverá a moverse para equilibrarse magnéticamente. Si se mantiene esta situación,
obtendremos un movimiento giratorio permanente del eje. El ángulo de paso depende de la
relación entre el nombre de polos magnéticos del estator y el nombre de polos magnéticos
del rotor.

Hay dos tipos de motores paso a paso: los unipolares y los bipolares.

Los bipolares se componen de 2 bobinas y los unipolares de 4 bobinas. Para diferenciarlos


físicamente basta con observar el número de terminales de cada motor. Los bipolares
siempre tienen 4 terminales, dos para cada bobina, y los unipolares normalmente tienen 6
terminales, dos para cada bobina y los otro dos son los comunes de estas. Hay motores
unipolares con 5 terminales en que los dos comunes están unidos internamente.
La diferencia entre los dos es que un motor paso a paso unipolar se activa una bobina a la
vez mientras que un motor bipolar se activa más de una bobina a la vez. Esto hace que un
motor bipolar tenga más torque que un motor unipolar. Por contra, un motor bipolar es más
complejo de controlar que un unipolar.

Secuencia para controlar motores paso a paso Bipolares

Un motor paso a paso bipolar necesita invertir la corriente que circula por sus bobinas en
una secuencia determinada para provocar el movimiento del eje.

Paso Bobina Bobina Bobina Bobina


1A 1B 2A 2B
Paso 1 1 0 1 0
Paso 2 1 0 0 1
Paso 3 0 1 0 1
Paso 4 0 1 1 0

Secuencia para controlar motores paso a paso Unipolares

Hay tres secuencias para controlar los motores paso a paso unipolares

Simple o wave drive: Es una secuencia donde se activa una bobina a la vez. Esto hace que
el motor tenga un paso más suave pero por el contrario tenga menos torque y menos
retención.

Paso Bobina Bobina Bobina Bobina


A B C D
Paso 1 1 0 0 0
Paso 2 0 1 0 0
Paso 3 0 0 1 0
Paso 4 0 0 0 1

Normal: Es la secuencia más usada y la que recomiendan los fabricantes. Con esta
secuencia el motor avanza un paso por vez y siempre hay dos bobinas activadas. Con esto
se obtiene un mayor torque y retención.

Paso Bobina Bobina Bobina Bobina


A B C D
Paso 1 1 1 0 0
Paso 2 0 1 1 0
Paso 3 0 0 1 1
Paso 4 1 0 0 1

Medio paso: Se activan primero dos bobinas y después solo una y así sucesivamente. Esto
provoca que el motor avance la mitad del paso real. Esto se traduce en un giro más suave y
preciso.

Paso Bobina Bobina Bobina Bobina


A B C D
Paso 1 1 0 0 0
Paso 2 1 1 0 0
Paso 3 0 1 0 0
Paso 4 0 1 1 0
Paso 5 0 0 1 0
Paso 6 0 0 1 1
Paso 7 0 0 0 1
Paso 8 1 0 0 1

Controlar motor paso a paso Bipolar con Arduino

Como hemos explicado antes, los motores bipolares son más complejos de controlar ya que
el flujo de corriente tiene que cambiar de dirección a través de las bobinas con una
secuencia determinada. Para esto debemos conectar cada una de las dos bobinas en un
puente en H (H-Bridge). Para esto, utilizaremos el integrado L293 que contiene dos H-
Bridge (datasheet).
PROGRAMA

// giro de motor con pulsadores en ambos sentidos segun la catidad de giros o grados que
determinemos.

int pulsador = 0;

int entrada = 2;

int pulsador1 = 0;

int entrada1 = 3;

int motorPin1 = 8; //Pin 1 del motor ... pin A del puente H

int motorPin2 = 9; //Pin 2 del motor ... pin B del puente H

int motorPin3 = 10; //Pin 3 del motor ... pin C del puente H
int motorPin4 = 11; //Pin 4 del motor ... pin D del puente H

int delayTime1 = 30; // DelayTime1 determina la velocidad de giro entre uno y otro paso

int count = 0;

void setup() {

pinMode(2, INPUT);

pinMode(3, INPUT);

pinMode(motorPin1, OUTPUT); // Configuración de los Pines como salida digital

pinMode(motorPin2, OUTPUT);

pinMode(motorPin3, OUTPUT);

pinMode(motorPin4, OUTPUT);}

void loop() {

pulsador = digitalRead(entrada);

if (pulsador == HIGH)

for (count = 0; count < 50; count++) /* (variable)donde podemos modificar la cantidad de
pulsos que se desean asignar al motor

para modificar la cantidad de giros o fraccion de giro, en sentido


contrario de las manesillas del reloj.

(50 pulsos para 360°)(25 pulsos para 180°)(10 pulsos para 72°) ETC.....
*/

// Punto A (Primero)

{digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);

digitalWrite(motorPin3, LOW);

digitalWrite(motorPin4, HIGH);

delay(delayTime1); // tiempo de espera

// Punto B (Segundo)

digitalWrite(motorPin1, HIGH);

digitalWrite(motorPin2, HIGH);

digitalWrite(motorPin3, LOW);

digitalWrite(motorPin4, LOW);

delay(delayTime1);

// Punto C (Tercero)

digitalWrite(motorPin1, LOW);

digitalWrite(motorPin2, HIGH);

digitalWrite(motorPin3, HIGH);

digitalWrite(motorPin4, LOW);

delay(delayTime1);

// Punto D (Cuarto)

digitalWrite(motorPin1, LOW);

digitalWrite(motorPin2, LOW);

digitalWrite(motorPin3, HIGH);

digitalWrite(motorPin4, HIGH);

delay(delayTime1); }

pulsador1 = digitalRead(entrada1);
if (pulsador1 == HIGH)

for (count = 0; count < 50; count++) /* (variable)donde podemos modificar la cantidad de
pulsos que se desean asignar al motor

para modificar la cantidad de giros o fraccion de giro, en sentido de


las manesillas del reloj.

(50 pulsos para 360°)(25 pulsos para 180°)(10 pulsos para 72°) ETC.....
*/

{ // Punto D (Cuarto)

digitalWrite(motorPin1, LOW);

digitalWrite(motorPin2, LOW);

digitalWrite(motorPin3, HIGH);

digitalWrite(motorPin4, HIGH);

delay(delayTime1);

// Punto C (Tercero)

digitalWrite(motorPin1, LOW);

digitalWrite(motorPin2, HIGH);

digitalWrite(motorPin3, HIGH);

digitalWrite(motorPin4, LOW);

delay(delayTime1);

// Punto B (Segundo)

digitalWrite(motorPin1, HIGH);

digitalWrite(motorPin2, HIGH);

digitalWrite(motorPin3, LOW);

digitalWrite(motorPin4, LOW);

delay(delayTime1);
// Punto A (Primero)

digitalWrite(motorPin1, HIGH);

digitalWrite(motorPin2, LOW);

digitalWrite(motorPin3, LOW);

digitalWrite(motorPin4, HIGH);

delay(delayTime1); }

SENSOR DE TEMPARATURA

PROGRAMA:

/* Programa: Medición de temperatura con Arduino+LM35+LCD2X16

ver video e información en youtube:


https://www.youtube.com/watch?v=c6Omj78oojo&feature=gp-n-
y&google_comment_id=z12jynujmxejfx1sk23hcnsxozracv00g

suscribete a mi canal: https://www.youtube.com/user/rubyck71


Profesor: Rubén Loredo Amaro, Universidad Tecnológica de Altamira*/

#include <LiquidCrystal.h>

LiquidCrystal lcd(12,11,5,4,3,2);

int rosa=8;

int PzSpeaker=10;

float centi()

int dato;

float c;

dato=analogRead(A0);

c = (500.0 * dato)/1024;

return(c);

void setup()

lcd.begin(16,2);

lcd.print("C=");

pinMode(8,OUTPUT); //declaramos el pin verde como salida

pinMode(PzSpeaker,OUTPUT);

void loop()

{
float Centigrados = centi();

if (Centigrados>30)

digitalWrite(8,HIGH); //encendemos el led rojo

delay(1000); //esperamos 2 segundos

digitalWrite(8,LOW); //apagamos el led rojo

playTone(600,500);

delay(25);

playTone(600,900);

delay(25);

lcd.setCursor(2,0);

lcd.print(Centigrados);

delay(200);

void playTone(long duracion,int frecuencia)

duracion*=1000;

int periodo =(1.0/frecuencia)*1000000;

long lapzo_de_tiempo=0;

while(lapzo_de_tiempo<duracion)

digitalWrite(PzSpeaker,HIGH);
delayMicroseconds (periodo/2);

digitalWrite(PzSpeaker,LOW);

delayMicroseconds(periodo/2);

lapzo_de_tiempo+=(periodo);

LED PWM

PROGRA,A

PROGRAMA

int led=5;

int brillo=0;

int aumento=5;

void setup() {

pinMode(led,OUTPUT);

pinMode(2,INPUT);

void loop()
{

if(digitalRead(2)==HIGH)

analogWrite(led,brillo);

brillo=brillo+aumento;

if(brillo==0||brillo==255)

aumento=-aumento;

delay(30);

SERVOMOTOR
PROGRAMA

#include <Servo.h>

Servo ServoPablo; //Declaramos que queremos controlar un Servo, al cual le vamos a poner un
nombre cualquiera

int pot = 0; //El pin análogo donde va conectado el Potenciómetro

int val; //El valor a leer por el puerto análogo

void setup()

ServoPablo.attach(9); //El pin al cual conectaremos nuestro Servo

void loop()

val = analogRead(pot); //Aquí le decimos que lea el valor del potenciómetro, valor el cual oscila
entre 0 y 1023

val = map(val, 0 ,1023, 0, 180); //Traduce la lectura análga (0, 1023) a grados (0°, 180°)

ServoPablo.write(val); //Mueve el Servo según la lectura análoga

delay(1);

Control de carga con un optoacoplador


En este proyecto utilizaremos un optoacoplador para el control de carga.

Este optoacoplador es un circuito integrado con dos componentes. Un fotoemisor que


activaremos con una de las salidas del Arduino y un fototransistor, que se activará con la
luz que emitirá el fotoemisor cuando sea activado, cerrando así el circuito.

Una de las ventajas de este dispositivo es que aisla totalmente los dos circuitos utilizando
una señal de luz para conectarlos.
Componentes

 arduino
 protoboard
 un optoacoplador
 un led
 dos resistencia de 220 Oms (rojo, rojo, cafe)

Circuito

El optoacoplador es un circuito integrado con seis patas, tres de ellas de cada lado del chip.

En un lado tenemos el fotoemisor con la alimentación en la pata 1 y la tierra en la pata 2.


La pata 3 no se utiliza. Para alimentar el fotoemisor debemos hacer lo mismo que hemos
hecho para alimentar otros leds, utilizar una resistencia que limite la corriente que llega al
fotoemisor.

En el otro lado del chip tenemos el fototransistor, con el colector en la pata 5 y el emisor en
la pata 6. La base esta en la pata 4 pero no vamos a utilizarla.

Como en los otros proyectos para el control de carga, utilizaremos un led para ver como
funciona nuestro circuito. Este led lo podemos sustituir despues por otros circuitos o
componentes, Aqui la diferencia importante es que las tierras de ambos circuitos no están
conectadas, son dos circuitos con su alimentación totalmente separada- al inicio

Diagrama
Código

En el código de este proyecto vamos a usar el mismo sketch que usamos para hacer una
disolvencia con un led y con esto probar que todo funciona.

/*

En este proyectos usaremos un optoacoplador para unir dos


circuitos

El otro circuito tiene un led al que cambiaremos el brillo

usando un pin con PWM pero a traves del optoacoplador

*/

// declaramos la constante para el pin del led y otras

const int pinOptoacoplador = 9; // guarda el numero del pin


para conectar el optoacoplador

const int incremento = 5; // incremento/decremento en el


brillo del led

const int pausa = 20; // tiempo entre cada incremento

void setup() {
// en el setup no necesitamos hacer nada
// con analogWrite no es necesario definir los pines como
OUTPUT
}

void loop() {
// hacemos un ciclo for para el fade desde el minimo al
maximo sumando incremento
// los valores del brillo estaran en el rango de 0 a 255):
for(int brillo = 0; brillo <= 255; brillo += incremento) {
analogWrite(pinOptoacoplador, brillo);
delay(pausa);
}

delay(pausa * 4); // esperamos un tiempo mayor para


empezar a apagarlo

// ahora hacemos el ciclo for para el fade desde el maximo


al minimo restando incremento
// los valores del brillo estaran en el rango de 255 a 0):
for(int brillo = 255 ; brillo >= 0; brillo -= incremento) {
analogWrite(pinOptoacoplador, brillo);
delay(pausa);
}
}