Tutorial de Arduino Uno · Arduino Uno R3 es una placa electrónica de las muchas que tiene Arduino...

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);


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 <WiFiClientSecure.h>

const char* ssid = "nombre 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



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


delay(500);


delay(1000);

}

Codigo – 5

//wifi.softAP

//Conectando NODEMCU como servidor


void setup()

{


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 <WiFiClient.h>

#include <ESP8266WebServer.h>

const char* ssid = "nombre de 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



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();


NODEMCU ESP12E

18

delay(500);


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() {


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.


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.


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); }

Tutorial de Arduino Uno · Arduino Uno R3 es una placa electrónica de las muchas que tiene Arduino...

Documents

Transcript of Tutorial de Arduino Uno · Arduino Uno R3 es una placa electrónica de las muchas que tiene Arduino...