ARDUINO UNO
1
Utilidad
Arduino Uno R3 es una placa electrónica de las muchas que tiene Arduino y con la
que es muy fácil introducirse en el mundo de la programación electrónica , Arduino
es una plataforma de código abierto (open-source) lo que permite realizar
proyectos y modificaciones tanto de hardware como de software a cualquier persona
sin ningún problema.
ARDUINO UNO
2
Electrónica
Datos técnicos de Arduino Uno.
Microcontrolador – Atmega328P.
Tensión de funcionamiento – 5 V.
Voltaje de entrada recomendado – 7 – 12V.
Voltaje de entrada límite – 20 V.
Digital Pines I/O – 14 (de los cuales 6 proporcionan una salida PWM).
PWM digital pines I/O – 6.
Pines de entrada analógica – 6.
Corriente DC por Pin I/O – 20 mA.
Corriente DC para Pin 3.3 V. – 60 mA.
Memoria Flash – 32 KB Atmega328P de los que 0.5 KB son utilizados p or el gestor de arran que.
SRAM - 2 KB Atmega328P.
EEPROM - 1 KB Atmega328P.
Velocidad de reloj - 16 MHz.
Longitud – 68.6 mm.
Anchura – 53.4 mm.
Peso – 25 g.
ARDUINO UNO
3
El diagrama de pines de Arduino Uno corresponde con la imagen siguiente:
Pin VIN:
Este pin se puede usar de varias formas, si tenemos una fuente de alimentación
conectada mediante un adaptador, lo que podemos hacer mediante este pin es
obtener la alimentación para conectar otro dispositivo pero tenemos que tener en
cuenta que la placa no regulara la tensión y obtendremos la misma tensión que
tenga el adaptador. Por otro lado si tenemos conectado el USB, la tensión será
regulada a 5v. Y si tenemos una fuente de alimentación externa como por ejemplo
pilas, el borne positivo de la pila ira conectado al pin VIN y el borne negativo de la
pila al pin GND, en este caso si la pila saca 10v la placa regulara la tensión a 5v.
Pin GND:
El pin GND es la tierra.
Pin 5v:
ARDUINO UNO
4
Este pin tiene varias funciones, podemos alimentar la placa mediante este pin,
siempre que tengamos la fuente externa regulada a 5v. Por otro lado si tenemos la
placa alimentada tanto por el Jack como por USB, se puede alimentar otro
componente con una tensión regulada de 5v.
Pin 3.3v:
Por este pin sacamos una tensión de 3.3v que es alimentada mediante el conector
Jack o el USB. Los 3.3v se utilizan para alimentar dispositivos que requieren una
tensión baja.
Pines de entradas analógicas:
La placa de Arduino cuenta con 6 pines de entradas analógicas, que van desde el
pin A0 al A5, de los cuales proporcionan 10bits, llamados bits de resolución. La
tensión que miden va de 0 a 5v, aunque es posible cambiar su rango usando una
función con el pin AREF.
Pin IOREF:
El pin IOREF es una copia del pin VIN y se utiliza para indicar a los demás
dispositivos conectador a la placa que las tensiones de los pines de entrada y salida
son 5v.
Pin RESET:
Este pin tiene el mismo funcionamiento que el botón RESET, se utiliza para reiniciar
el microcontrolador.
Pines de entradas y salidas digitales:
Las entradas y salidas digitales son 14 y van desde el pin 0 al 13 y ofrecen una
tensión de 5v.
ARDUINO UNO
5
Pines A5 SCL y A4 SDA:
Se pueden utilizar para conectar dispositivos que lleven a cabo comunicaciones
mediante la librería Wire.
Pin AREF:
Ofrece un voltaje de referencia para las entradas analógicas.
Pines 1 TX y 0 RX:
Estos pines se utilizan para recibir y transmitir datos en serie.
El mapa de pines de Arduino Uno corresponde con la imagen siguiente:
ARDUINO UNO
6
Imagen correspondiente con la placa electrónica de Arduino Uno:
ARDUINO UNO
7
De la imagen de arriba podemos separar tres zonas con funciones diferentes:
La primera zona podemos ver la regulación del voltaje de entrada a la placa:
En la segunda zona podemos la administración de voltaje para demás partes de
la placa:
ARDUINO UNO
8
En la tercera zona podemos ver la dirección de los datos entre el microcontrolador Atmega16u2, el microcontrolador Atmega328P, el oscilador de cristal, etc.
ARDUINO UNO
9
Programación
El entorno de programación más utilizado es Arduino IDE, descargable desde la
pagina oficial de arduino:
https://www.arduino.cc/en/main/software
Lo único que debemos hacer es seleccionar el sistema operativo desde donde
vamos a ejecutar nuestro entorno arduino ide y listo.
Cuando abrimos el entorno de programación "arduino ide" veremos la siguiente
ventana donde podremos empezar a programar:
ARDUINO UNO
10
En el menu horizontal superior podemos ver las pestañas : Archivo, editar,
programas, herramientas y ayuda.
Una vez conectada nuestra placa Arduino Uno al ordenador a través del puerto USB
deberemos seleccionarla desde la pestaña herramientas, dentro de herramientas
seleccionaremos "Placa" y dentro de placa seleccionamos "Arduino/Genuino Uno".
Por último tendremos que seleccionar el puerto que el ordenador te asigna para
comunicarte con el entorno de programación, esto lo haremos desde la pestaña
"herramientas", dentro de "herramientas" seleccionamos "puerto", y dentro de
"puerto" tendremos que ver el puerto asignado para la comunicación vía usb con la
placa arduino.
Un primer programa para comprobar que todo funciona correctamente podría el
siguiente de abajo.
El resultado de este programa es encender el led interno en la placa arduino y
apagarlo con un intervalo de un segundo.
Con este ejemplo verificamos que tanto la comunicación como la ejecución del
programa funciona correctamente.
ARDUINO UNO
11
Codigo – 1
// Este es un pequeño ejemplo para comprobar el funcionamiento de la placa con el
// entorno de programación, en este ejemplo se enciende y se apaga un led
int ledPin = 13; void setup(){ pinMode(ledPin, OUTPUT); } void loop(){ digitalWrite(ledPin, HIGH); delay(1000); digitalWrite(ledPin, LOW); delay(1000); }
NODEMCU ESP12E
1
Utilidad
NodeMCU es una pequeña, barata y simple placa electrónica, la puedes utilizar
como receptor o emisor wifi, dispone de entradas y salidas tanto digitales como
analógicas, perfecto para diseñar prototipos tipo arduino con casi las mismas
prestaciones. Este pequeño circuito utiliza la ESP8266.
La última NodeMCU utiliza el módulo ESP32 con mejoras respecto a la versión
anterior ESP12.
NodeMCU es capaz de conectarse vía wifi con un dispositivo, como por ejemplo un
ordenador, una tablet o un móvil, para recibir o transmitir información. Al mismo
tiempo es capaz de interactuar con motores, leds, sensores de temperatura,
detectores de humo, relés, etc.
NODEMCU ESP12E
2
Electrónica
Datos técnicos del módulo NODEMCU ESP12E.
Tensión de trabajo – 3.3 VDC.
Corriente de trabajo – entre 50 mA y 300 mA.
Procesador – 32 bits a 80 MHz o 160 MHz.
Memoria IRAM – 35K.
Memoria DRAM – 80 K.
Memoria Flash – 32 Megabits ( 4 Megabytes ).
Protocolo red local – 802.11 b/g/n.
Comunicación – Wifi Direct (P2P) Soft-AP.
Protocolo – Stack TCP/IP.
Frecuencia red Wifi – Interfaz Wifi 2.4 GHz.
Pulsador para Flash.
Pulsador para Reset.
Conector Micro USB.
Pins GPIO (Input-Output) y PWM de 0-12.
Pin entrada analógica AD0.
Chip CH340G dedicado a USB-UART.
NODEMCU ESP12E
3
El pin que utiliza para encender el led interno es el GPIO16 o D0, y debe estar en
estado LOW para encenderse.
Pins GPIO . Los pins gpio (General Purpose Input/Output) son los destinados a
entradas y salidas digitales.
El pin A0 (ADC0) o TOUT , es el destinado a entradas analógicas. Este pin recibe
una señal que dependiendo del receptor modula la tensión de entrada al pin A0, el
rango de la tensión puede estar entre 0 y 5 Voltio (dependiendo del emisor). La
tensión es recibida por la entrada y convertida en valores digitales que van del 0 al
1024.
Los pines PWM se pueden utilizar para las salidas analógicas.
Los pines SPI (Serial Peripheral Interface) se utilizan para las comunicaciones
entre circuitos integrados siguiendo un protocolo de comunicación sincrono, como
NODEMCU ESP12E
4
por ejemplo con pantallas OLED. Entre los pines SPI tenemos SPICLK, SPIQ
(MISO), SPID (MOSI) y SPICS.
Pines UART (Universal asynchronous Receiver / Transmitter) Los pines UART los
utilizamos para la recepción (RX) y transmisión (TX) de datos de la nodemcu. Los
datos enviados a través de los pines UART nos permiten configurar tanto la
velocidad de transmisión de los datos como su formato.
Los pines UART en la nodemcu son TXD0 (GPIO1), RXD0 (GPIO3), TXD1 (GPIO2),
TXD2 (GPIO15), RXD2 (GPIO13).
Hay que tener en cuenta que en la nodemcu no se pueden utilizar dos transmisiones
de datos simultáneamente a pesar de que si dispone de dos puertos diferentes para
esto.
Pin Flash. El pin flash (GPIO0) es recomendable tenerlo en un estado "LOW", es
decir puesto a tierra cada vez que quieras flashear tu nodemcu, al igual que el pin
GPIO15. Por el contrario se deberá dar tensión de 3.3V (estado HIGH) al pin
GPIO2, a través de una resistencia de 3.3k.
Cuando conectamos la nodemcu a través del cable usb y flasheamos la tarjeta, esta
automáticamente pone los pines GPIO0, GPIO2 y GPIO15 en el estado descrito
arriba sin necesidad de cablearla.
NODEMCU ESP12E
5
Programación
Entorno de programación para NodeMCU con "Arduino i de".
Un entorno de programación para realizar nuestros proyectos con la nodemcu es el
arduino ide, puedes descargarlo desde este enlace : arduino ide.
Una vez tienes instalado el entorno de programación debes configurarlo para poder
empezar a trabajar con nodemcu, para configurarlo debes clickear en
"Archivo", luego "preferencias"
NODEMCU ESP12E
6
En la casilla "Additional Boards Manager URLs" debes escribir la siguiente dirección
: http://arduino.esp8266.com/stable/package_esp8266com_index.json
Después de clickear "Ok" deberás instalar el plugin de nodemcu.
El siguiente paso para instalar el plugin será acceder a "Herramientas", luego
seleccionar "Placa:" y después clickear en "Boards Manager"
NODEMCU ESP12E
7
Una vez accedes a "Boards Manager" deberás buscar esp8266,
Y una vez instalado, ya podrás acceder a la configuración de la placa nodemcu para
programar tu tarjeta.
NODEMCU ESP12E
8
Entorno de programación para NodeMcu con "ESPlorer" .
Hasta ahora he utilizado con muy buenos resultados el “ESPlorer”, la página oficial
es http://esp8266.ru/ESPlorer/, desde donde te puedes descargar el programa y
diferentes manuales.
Recuerda que debes tener instalado Java para que el entorno de programación
pueda ejecutarse.
También tenemos esta otra pagina muy interesante para programar nuestro
Nodemcu http://nodemcu.readthedocs.io/en/master/.
NODEMCU ESP12E
9
Este es el aspecto que tiene nuestro entorno de programación para NodeMcu:
En esta ventana podemos ver marcados en rojo y numerados, los siguientes
apartados:
1. Con el número 1 tenemos indicado el puerto de comunicación que estamos
utilizando para conectarnos a nuestro NodeMcu. Justo debajo del número
uno tenemos los botones: DTR (Terminal del dato listo, deberá estar
seleccionado), RTS (Solicitud para enviar, y deberá estar seleccionado) y
CTS (Limpiar para enviar, y este botón no es necesario que este
seleccionado).
2. con el número 2 establecemos comunicación clickeando en "open".
3. En el número 3 indicamos la velocidad de transferencia de comunicación en
baudios.
4. En número 4 es la pestaña donde se encuentra el script que contiene las
instrucciones de nuestro programa.
5. En el número 5 vemos la ventana que utiliza ESPlorer para mostrar las
instrucciones que hacen referencia al estado en el que se encuentra nuestra
NodeMcu con nuestro entorno de programación ESPlorer.
6. La ventana número 6 muestra las lineas de código del script que queremos
transferir al NodeMcu.
NODEMCU ESP12E
10
7. En el número 7 tenemos el boton "Save&Run" para transferir el programa al
nodeMcu.
Codigo – 1
// En este ejemplo podemos ver la escritura de un "hola mundo" en el monitor del
//entorno de arduino y el encendido y apagado del led interno de la placa.
void setup() { Serial.begin(115200); pinMode(LED_BUILTIN, OUTPUT); } void loop() { Serial.println("hola mundo"); digitalWrite(LED_BUILTIN, LOW); delay(500); digitalWrite(LED_BUILTIN, HIGH); delay(1000); }
Codigo - 2 //Con este código veras el resultado del sensor de temperatura y humedad DHT11
// la placa NODEMCU
#include "DHT.h"
#define DHTTYPE DHT11 // DHT 11
// DHT Sensor
const int DHTPin = 2; //el número 2 corresponde con el pin D4 en ESP12, para el
//ESP32 el D4 es el 4
//otra opción sería definir una constante para el pin D4 por ejemplo #define DHTPin
//D4
NODEMCU ESP12E
11
DHT dht(DHTPin, DHTTYPE);
void setup() {
Serial.begin(115200);
dht.begin();
}
void loop() {
float h = dht.readHumidity();
float t = dht.readTemperature();
Serial.print("DHT Temperatura: ");
Serial.print(t);
Serial.print(" ºC\t Humedad: ");
Serial.print(h);
Serial.println(" % ");
delay(500);
}
Codigo – 3
// Conectando wifi http con NODEMCU
//esp8266wifi
#include <ESP8266WiFi.h>
const char* ssid = "nombre de la red wifi";
const char* password = "contraseña de la red wifi";
NODEMCU ESP12E
12
const char* host = "www.freepik.com";// este host es un ejemplo http
const int httpPort = 80;
void setup() {
WiFi.mode(WIFI_STA);//modo cliente
WiFi.begin(ssid, password);
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("IP:");
Serial.println(WiFi.localIP());
WiFiClient client;
if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}
// This will send the request to the server
client.print(String("GET /") + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Connection: close\r\n" +
"\r\n"
);
while (client.available()) {
String line = client.readStringUntil('\r');
Serial.print(line);
}
NODEMCU ESP12E
13
}
void loop() {
// el contenido del loop lo único que hace es encender el led dela placa nodemcu
digitalWrite(LED_BUILTIN, LOW);
delay(500);
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
}
Codigo – 4
//wificlientsecure
//Este codigo conecta wifi https con NODEMCU
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
const char* ssid = "nombre de la red wifi";
const char* password = "contraseña de la red wifi";
const char* host = "url del host, por ejemplo www.infootec.net"; //ejemplo de una
pagina protocolo https
const char* huella = "aqui escribimos la huella digital que nos proporciona la
pagina";
const int httpsPort = 443;
WiFiClientSecure client;
void setup() {
WiFi.mode(WIFI_STA);//modo cliente
WiFi.begin(ssid, password);
Serial.begin(115200);
pinMode(LED_BUILTIN, OUTPUT);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
NODEMCU ESP12E
14
Serial.print(".");
}
Serial.println("");
Serial.println("IP:");
Serial.println(WiFi.localIP());
Serial.print("connecting to ");
Serial.println(host);
if (!client.connect(host, httpsPort)) {
Serial.println("connection failed");
return;
}
if (client.verify(huella, host)) {
Serial.println("certificate matches");
} else {
Serial.println("certificate doesn't match");
}
client.println("GET (aqui escribimos la url del archivo html que queremos)
HTTP/1.1");
client.println("Host: (aqui escribimos url del host)");
client.println("Connection: close");
client.println();
Serial.println("request sent");
while (client.connected()) {
String line = client.readStringUntil('\n');
Serial.println(line);
if (line == "\r") {
Serial.println("headers received");
NODEMCU ESP12E
15
String line = client.readStringUntil('\r');//hay un límite en la longitud de la página
Serial.println(line);
break;
}
}
}
void loop() {
// el contenido del loop lo único que hace es encender el led dela placa nodemcu
digitalWrite(LED_BUILTIN, LOW);
delay(500);
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
}
Codigo – 5
//wifi.softAP
//Conectando NODEMCU como servidor
#include <ESP8266WiFi.h>
void setup()
{
Serial.begin(115200);
Serial.println();
Serial.print("Setting soft-AP ... ");
boolean result = WiFi.softAP("hola", "12345678");
if(result == true)
{
Serial.println("Ready");
}
else
{
NODEMCU ESP12E
16
Serial.println("Failed!");
}
}
void loop()
{
Serial.printf("Stations connected = %d\n", WiFi.softAPgetStationNum());
delay(3000);
}
Codigo – 6
//Servidor y cliente
//Conectando NODEMCU como servidor y cliente al mismo tiempo
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
const char* ssid = "nombre de red wifi";
const char* password = "contraseña de la red wifi";
IPAddress ip(192,168,0,10);
IPAddress subnet(255,255,255,0);
ESP8266WebServer server(80);
void handleRoot() {
String page = "<!DOCTYPE html>\n";
page += "<html>\n<body>\n<h1>Hola</h1><br>Pagina alojada en
NodeMCU\n</body>\n</html>";
server.send(200, "text/html", page);
}
void setup(){
WiFi.mode(WIFI_AP_STA);
NODEMCU ESP12E
17
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED){
delay(500);
Serial.print(".");
}
if (WiFi.status()){
Serial.println("");
Serial.println("Red wifi conectada:");
Serial.println(ssid);
}
WiFi.softAPConfig(ip, ip, subnet);
WiFi.softAP("hola", "12345678", 7);
IPAddress myIP = WiFi.softAPIP();
Serial.print("AP IP address: ");
Serial.println(myIP);
server.on("/", handleRoot);
server.on("/test", [](){
server.send(200, "text/html", "<h3>Subdirectorio alojado en NodeMCU</h3>");
});
server.begin();
Serial.println("HTTP servidor arrancado...");
}
void loop(){
server.handleClient();
digitalWrite(LED_BUILTIN, LOW);
NODEMCU ESP12E
18
delay(500);
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
}
DHT11
1
Utilidad
Este sensor de humedad y temperatura es de D-Robotics y con él puedes obtener
un muy buen resultado, en mi opinión, con bastante precisión.
Con este sensor dht11 consigues tener una medida de la temperatura y humedad
muy exacta, con una respuesta rápida y sin interferencias.
Es un sensor resistente, sencillo y muy práctico con un precio muy económico.
El sensor dht11 dispone de 3 pins, un pin para la entrada de tensión, otro pin para
la masa, y otro pin para la transferencia de datos.
Es capaz de transmitir la información hasta 20 metros de distancia , la tensión de
alimentación es de 3 a 5.5 Voltios en continua, con una corriente de trabajo de 2.5
miliamperios.
Con este sensor podemos medir temperaturas entre 0 y 50 grados Centigrados
con un error de mas menos un 2%, y en cuanto a la humedad podemos medir el
porcentaje de humedad con un rango entre 20 y 90% de humedad y un margen de
error de un mas menos 5%.
DHT11
2
Electrónica
Datos técnicos del sensor DHT11.
Tensión de trabajo - 5 VDC.
Corriente de trabajo – 2.5 mA.
Distancia de medida – hasta 20 mts.
Pin Vcc - Entrada de tensión 5 VDC
Pin GND - Salida a tierra
Pin S – Pin que nos proporciona la salida de la señal, esta señal tiene una resolución de 8 bits y está acompañada con una resi stencia pull-up de 5k a la salida de la placa.
Instalación de DHT11 con NODEMCU ESP12
Para ver la lectura de temperatura y humedad del sensor dht11 vamos a utilizar el
circuito impreso NodeMCU.en este ejemplo.
Conectaremos el sensor dht11 con los pines de los extremos para dar tensión al
sensor a los pines de tensión de la nodemcu, que son los cables marrones, y el pin
de datos que está en el medio de los pines del sensor irá conectado al pin "D5",
entrada de señal digital del nodemcu, es el cable morado.
DHT11
3
En la imagen de abajo podemos ver la composición externa al propio sensor
dht11 que incluye esta versión del sensor. En la placa tenemos un condensador de
filtro diseñado para rectificar las fluctuaciones de tensión en la alimentación ya sea
3.3 voltios o 5 voltios.
También tenemos una resistencia pull-up diseñada para evitar el ruido o las
medidas erróneas de la señal enviadas al MCU o en nuestro caso a la NODEMCU.
DHT11
4
En la imagen de abajo vemos destripado el sensor DHT11 donde se puede apreciar
un conjunto de resistencias abajo y arriba la memoria OTP (one-time-
programmable) donde quedan grabados los coeficientes de medición, calculados en
el proceso de calibración del sensor.
En la imagen de abajo vemos los dos sensores de temperatura y el de humedad. El
sensor de temperatura es de tipo NTC (mide la temperatura a través de una
resistencia) y el sensor de humedad HR202.
DHT11
5
En la siguiente imagen vemos el protocolo para el envío de datos del sensor DHT11.
La señal se compone de 40 bits transferidos, estos 40 bits transferidos se
componen de 8 bits para indicar el valor de la humedad con formato entero , más
8 bits para transmitir la señal de la humedad con un formato decimal , luego 8
bits más para transmitir la temperatura en formato entero más 8 bits para enviar
la señal de temperatura en formato decimal , y los últimos 8 bits son para enviar
un check sum que verifica la información anterior por si hubiera errores.
Por ejemplo:
8 bits de dato integral de T = 0x01 más 8 bits de dato decimal de T = 0x32
El resultado de la temperatura medida es:
((0x01 << 8) + 0x32) / 10 = ( 256 + 50 ) / 10 = 30.6 grados centígrados.
DHT11
6
Programación
//Programación con arduino
#include "DHT.h"
#define DHTTYPE DHT11 // DHT 11
// DHT Sensor
const int DHTPin = 3; //el número 3 corresponde con el pin D5 en ESP12, para el
//ESP32 el D5 es el 5
//otra opción sería definir una constante para el pin D5 por ejemplo #define DHTPin
//D4
DHT dht(DHTPin, DHTTYPE);
void setup() {
Serial.begin(115200);
dht.begin();
}
void loop() {
float h = dht.readHumidity();
float t = dht.readTemperature();
DHT11
7
Serial.print("DHT Temperatura: ");
Serial.print(t);
Serial.print(" ºC\t Humedad: ");
Serial.print(h);
Serial.println(" % ");
delay(500);
}
HC-SR04
1
Utilidad
El sensor HC-SR04 lo podemos utilizar para medir distancias, dispone de un
transmisor que emite ondas sonoras y el receptor las recibe después de rebotar en
un objeto, el tiempo que transcurre desde que sale la onda hasta que la recibe el
receptor se utiliza para calcular la distancia al objeto.
En la imagen de arriba el transmisor está situado en la izquierda mientras que el
receptor está a la derecha, dispone de 4 pines, dos pines para la alimentación, un
pin para indicar cuándo quieres que emita el pulso de sonido (Trig), y otro pin que
se utiliza para enviar la señal procesada de la recepción del sonido .
Puede detectar objetos desde 2 centímetros hasta 400 cm, con una precisión de 3
mm y un ángulo de cobertura de medición de 15 grados.
HC-SR04
2
El funcionamiento de este sensor comienza con la instrucción:
digitalWrite(TriggerPin, HIGH);
En este momento desde el pin "TriggerPin" de nuestra placa, por ejemplo arduino,
deberá salir una señal de 5 voltios con una duración de 10 microSegundos.
Cuando el sensor detecta esta señal, desde la membrana "T" emite una onda
sonora, esta onda sonora está compuesta de 8 pulsos de 5 voltios y 40 Hercios
cada uno de ellos. Estos 8 pulsos son emitidos desde la membrana del transmisor,
rebotados (o no) en el medio físico a detectar y recogidos por la membrana del
receptor "R".
Cuando el sensor detecta los 8 pulsos calcula el tiempo que ha tardado desde que
las ondas salieron del emisor hasta que las recibió el receptor. Una vez calculado el
tiempo, desde el pin Echo del sensor se emitirá una señal de 5 voltios con un ancho
proporcional al tiempo calculado.
Para que nuestra placa pueda escuchar o reciba la señal emitida por el sensor,
utilizaremos la instrucción:
HC-SR04
3
Duración = pulseIn(EchoPin,HIGH);
Con esta instrucción transformamos el ancho de la señal de 5 voltios que emite
"EchoPin" en microsegundos. En este caso una vez tenemos el valor en
microsegundos lo guardamos en la variable "Duración".
HC-SR04
4
Electrónica
Datos técnicos del sensor HC-SR04.
Tensión de trabajo - 5 VDC.
Corriente de trabajo - 15 mA.
Frecuencia de trabajo - 40 Hz.
Distancia de medida - desde 2 cm a 400 cm.
Ángulo de medida - 15 grados.
Pin Vcc - Entrada de tensión 5 VDC
Pin GND - Salida a tierra
Pin Trig - Cuando recibe una señal digital emite un sonido, co nectado a una salida digital de nuestra placa.
Pin Echo - Emite una señal digital cuando el receptor recibe e l sonido emitido por el emisor, conectado a una entrada digital de n uestra placa.
HC-SR04
5
Esquema eléctrico de la placa HC-SR04 del sensor ul trasonidos:
HC-SR04
6
En el esquema de arriba vemos 3 circuitos integrados, el STC11, TL074 y MAX232: En el interior del circuito TL074 (LM324 de Texas I nstruments) podemos encontrar:
El circuito MAX232 es el siguiente:
El circuito integrado STC11, donde se procesa la in formación:
HC-SR04
7
Este integrado responde al siguiente diagrama de fu nciones:
HC-SR04
8
Diagrama de conexión eléctrica con la placa NodeMCU .
HC-SR04
9
Diagrama de conexión eléctrica con la placa Arduino Uno.
En este diagrama de conexión tenemos el cableado de tierra, masa o negativo de
color negro, el cableado que esta conectado al positivo o a la alimentación es de
color rojo desde donde suministraremos 5 voltios de tensión.
Los dos cables de color azul los utilizaremos para la transferencia de datos, en este
caso el GPIO12 o PIN 12 en arduino estará conectado con el pin "trig" de nuestro
sensor ultrasonidos HC-SR04 y cuando este pin reciba tensión con la instrucción
siguiente ( la instrucción pertenece al ejemplo de programación más abajo):
digitalWrite(TriggerPin, HIGH);
en ese momento el sensor ultrasonidos emitirá un sonido de 8 pulsos con una
frecuencia 40 KHz, el tiempo de disparo para activar el pin "trig" es de 10 µS.
HC-SR04
10
Esta onda de sonido debe ser recogida por el receptor del sensor de ultrasonido,
después de calcular el tiempo que ha tardado la onda se emite una señal a través
de Echo hacia al GPIO13 o PIN13 en arduino.
pulseIn(EchoPin,HIGH);
Esta instrucción pertenece al codigo del ejemplo más abajo. Con la función pulseIn
activamos el PIN13 en arduino o GPIO13 en nodemcu y lo que devuelve esta
función es un valor en microsegundos en relación a la señal emitida por el pin Echo
del sensor.
HC-SR04
11
Programación
Código – 1
Este ejemplo es muy básico y cuenta únicamente con el código para poner en
marcha el sensor e imprimir el resultado, también saber que en este código
utilizamos un “delay” en microsegundos de 1000 µS, después del “Trigger, LOW”, y
al terminar el “loop” utilizamos un “delay” de 300 milisegundos para detener la
ejecución del código durante ese tiempo antes de volver a ejecutar el “loop” (existen
otras maneras de pausar el código aunque ahora utilizaremos el “delay”):
// Ejemplo sensor ultrasonidos
const int Trigger = 13; // asignamos una constante de tipo entero al
// pin 13
const int Echo = 12; // asignamos una constante de tipo entero al
// pin 12
long duracion; // asignamos una variable de tipo long
// El codigo “void setup” se ejecuta una sola vez en la ejecución del //
programa
void setup() {
pinMode(Trigger, OUTPUT); // indicamos que el pin 13, asignado a la
// constante Trigger, lo utilizaremos como
// salida de señal.
pinMode(Echo, INPUT); // indicamos que el pin 12, asignado a la
// constante Echo, lo utilizaremos como
// entrada de señal.
Serial.begin(115200); // indicamos la velocidad en baudios a
HC-SR04
12
// la transmisión por el puerto “Serial”
}
// El código “void loop” se ejecuta constantemente como bucle
void loop() {
digitalWrite(Trigger, LOW); // colocamos el pin 13 en estado LOW
delayMicroseconds(1000); // detenemos el procesador 1000 µS
digitalWrite(Trigger, HIGH); // pin 13 en estado HIGH (activado)
delayMicroseconds(10);
digitalWrite(Trigger, LOW);
12uración = pulseIn(Echo, HIGH);
12uración = (12uración / 2.9) / 2; //calculamos en milímetros la señal
Serial.println(12uración); // imprimimos por el puerto serial la duración
delay(300); // detenemos el procesador 300 miliSegundos
}
Codigo - 2
Este ejemplo imprime el resultado en milímetros por el monitor del IDE de arduino.
El código utiliza una función, long Distance(long time) , para calcular la distancia,
con este código utilizamos un delayMicroseconds de 2:
//Ejemplo de código para utilizarlo con NodeMCU o Arduino Uno
const int TriggerPin = 12; //Trig pin
const int EchoPin = 13; //Echo pin
long Duration = 0;
void setup(){
pinMode(TriggerPin,OUTPUT); // Trigger es una salida
pinMode(EchoPin,INPUT); // Echo es un pin de entrada
HC-SR04
13
Serial.begin(115200); // salida por el puerto serial
}
void loop(){
digitalWrite(TriggerPin, LOW);
delayMicroseconds(2);
digitalWrite(TriggerPin, HIGH); // Activamos el pin Trigger (pin 12)
delayMicroseconds(10); // esperamos 10 microsegundos
digitalWrite(TriggerPin, LOW); // Desactivamos el pin Trigger
Duration = pulseIn(EchoPin,HIGH); // Activamos el pin Echo (pin
//13)
// La función pulseIn nos devuelve la duración
// de la señal
long Distance_mm = Distance(Duration); // Mediante la duración
// calculamos la distancia
Serial.print("Distance = "); // Escribimos por monitor
Serial.print(Distance_mm);
Serial.println(" mm");
delay(1000); // Esperamos un segundo
}
// Creamos una función que se llama “Distance” para convertir la señal del sensor
// enviada en milimetros
long Distance(long time)
{
// Calculo de la distancia en mm
// ((time)*(Velocidad del sonido))/ ida y vuelta al objeto) * 10
HC-SR04
14
long DistanceCalc; // Calculation variable
DistanceCalc = ((time /2.9) / 2); // Calculo en mm
//DistanceCalc = time / 74 / 2; // Calculo en pulgadas
return DistanceCalc; // la funcion devuelve el valor en mm
}
MG995
1
Utilidad
Servomotor capaz de mover 180 grados con un torque de unos 10 kg por
centímetro, y una velocidad de 0.20 segundos 60 grados.
Con un servomotor somos capaces de posicionar el eje del motor y por lo tanto el
dispositivo que fijemos al eje en una posición concreta dentro de un ángulo de
trabajo de 180 grados.
Este servomotor tiene unas medidas de 20 mm de ancho, 54 mm de largo y 47.2
mm de alto, lo podemos utilizar para realizar funciones que requieren movimientos
con cierta precisión o incluso con una alta precisión.
MG995
2
El servomotor lo podemos utilizar por ejemplo en movimientos para articulaciones
tipo brazos robóticos, pinzas, movimiento para sensores, etc.
Dentro de la parte mecánica incluye varios engranajes de cobre y dos cojinetes de
bolas.
El juego de engranajes tiene un tope para bloquear el servo cuando supera los 180
grados tanto en un sentido como en otro. El tope junto con el potenciómetro marcan
el límite de cada posición.
MG995
3
Electrónica
Datos técnicos del servomotor MG995.
Tensión de trabajo - 5 VDC.
Corriente de trabajo - 100 mA.
Fuerza de trabajo – 10 kg por centímetro.
Temperatura de trabajo – entre -20 y 60 grados.
Pin Vcc - Entrada de tensión 5 VDC, cable rojo
Pin GND - Salida a tierra o masa, cable negro o marrón
Pin Señal - Entrada analógica para indicar la posición del serv omotor, cable de color amarillo o blanco.
Constitución - El material de construcción es metal, con un reduct or de dientes de cobre y dos cojinetes de bolas. En la imagen de abajo está indicado el tipo de conexión eléctrica del servomotor con
el color correspondiente del cableado que incluye.
MG995
4
En la siguiente imagen se puede ver la representación de los 0 grados y el pulso
eléctrico a que equivale para indicar esa posición.
También tenemos representada la posición de 90 grados y 180 grados, pulsos
repetidos a 50 Hz.
En la imagen de abajo puedes ver la tarjeta controladora del servomotor, con un
convertidor que convierte la señal en pulso eléctrico y un puente H para realizar
movimientos en ambos sentidos.
MG995
5
Programación
Codigo – 1
// Código probado desde el arduino uno. #include <Servo.h> Servo servo1; int angulo = 90; void setup() { servo1.attach(3); Serial.begin(9600); } void loop() { servo1.write(angulo); }
Codigo - 2 //servomotor #include <Servo.h> Servo servo1; int angulo=10; int caracter; void setup() { servo1.attach(14); Serial.begin(115200); } void loop() { if (Serial.available()>0){ if (Serial.read()>10){ caracter = Serial.read(); // angulo = (caracter)-48; } Serial.println("caracter"); Serial.println(caracter); //Serial.println("angulo"); //Serial.println(angulo);
MG995
6
for (int i=10;i<=150;i+10){ servo1.write(i); Serial.println(i); i=i+10; delay(1000); } } delay(1000); }