Content uploaded by Jorge Acuña Moya
Author content
All content in this area was uploaded by Jorge Acuña Moya on Sep 07, 2017
Content may be subject to copyright.
1
2
!
3
Autores
Herman Aguirre Jofré es Ingerniero Civil en Minas con experiencia
en Gestión de Operaciones Mineras. Actualmente desarrolla trabajo de
investigación Docente, siendo su principal área de interés la
masificación de la tecnología y la difusión de herramientas de análisis
de datos.
Herman.aguirrej@gmail.com
http://www.facebook.com/miningideas
Jorge Acuña Moya es estudiante de Ingeniería Civil en Minería y
durante toda su carrera ha estudiado y desarrollado prototipos
tecnológicos que permitan adquirir datos desde faenas mineras.
joacunam@ingenieros.udd.cl
Francisco Rojas Vera es Ingeniero Civil con Diploma en Minería. Ha
desempeñado funciones en diversos tipos de operaciones y siempre
ha ostentado una fuerte habilidad como desarrollador en lenguajes de
programación.
fj.rojas.v@gmail.com
4
Tabla de Contenidos
Autores ................................................................................................................................................................................. 3
Tabla de Contenidos ......................................................................................................................................................... 4
Invitación ............................................................................................................................................................................. 5
Introducción ........................................................................................................................................................................ 6
¿Qué es Arduino? .......................................................................................................................................................................... 7
Breve explicación del IDE y la programación orientada a objetos ................................................................................. 8
Breve introducción a los circuitos eléctricos ........................................................................................................................ 10
Partes fundamentales de un Arduino .................................................................................................................................... 12
Encender y apagar un LED ....................................................................................................................................................... 14
3 LEDS y protoboard .................................................................................................................................................................. 19
Sensores y transmisión de datos ............................................................................................................................... 21
Medición de temperatura con termistor ................................................................................................................................ 22
Lector de gas y envío de datos vía Bluetooth .................................................................................................................... 24
Envío de datos mediante antena NRF24 ............................................................................................................................... 27
Visualización Gráfica ...................................................................................................................................................... 32
Conexión a base de datos SQL. .............................................................................................................................................. 33
Sensor Termistor con conexión a base de datos para despliegue web ...................................................................... 37
5
Invitación
El siguiente documento tiene por objetivo explicar de la forma más básica posible el funcionamiento
de un Arduino, entregando las primeras definiciones e instrucciones que permitan al lector manipular
y trabajar con ellos.
Se explicarán para qué sirven estas diminutas placas programables, su ambiente de trabajo de
programación y sus principales componentes.
Para motivar aún más a quien use este tutorial, se entregan ejemplos sencillos para encender LEDS,
enviar datos desde un dispositivo a otro y calcular temperaturas ambientes con sensores de bajo
precio, pero de alto poder tecnológico.
Se espera compartir con la mayor cantidad de personas este conocimiento que poco a poco irá
dominando cada rincón de nuestro planeta, necesitando mentes despiertas y preparadas para
asumir desafíos mayores.
6
Introducción
!
7
¿Qué es Arduino?1
Arduino es una plataforma electrónica open –source basada en hardwares y softwares fáciles de usar.
Los Arduinos son capaces de leer una señal y convertirlo en una respuesta. Por ejemplo, son capaces
de recoger luces de un sensor, leer pulsos de botones o recibir mensajes de twitter para luego activar
un motor, encender un LED o publicar algo en Internet.
Puedes explicar al Arduino lo que deseas hacer por medio de un set de instrucciones cargables en su
memoria interna, las que serán procesadas por su microcontrolador.
Para ello es necesario el uso de un lenguaje de programación de Arduino (basado en WIRING) y un
espacio de trabajo (Arduino Software o IDE) basado en Processing.
Referencias para aprendizaje:
https://www.arduino.cc/en/Guide/HomePage
1 Información extraída de https://www.arduino.cc/en/Guide/Introduction. Allí es posible encontrar la descripción completa
de objetivo de Arduino y sus modos de uso.
8
Breve explicación del IDE y la programación orientada a objetos
La programación orientada a objetos es un tipo de programación que permite al programador crear
funciones (métodos) y llamarlas en cualquier momento durante el desarrollo de la programación. Esto
trae en consecuencia una tremenda ventaja, ya que no debemos escribir el código de dicha función
cada vez que queramos llamarla, sino que la creamos una sola vez y posteriormente cada vez que
necesitemos utilizarla la llamamos asignándole las variables de entrada.
Arduino, permite al usuario descargar desde su página web el software de programación Arduino, el
cual consiste en un tipo de programación orientada a objetos. Básicamente su estructura está
caracterizada por dos funciones principales; void setup () y void loop ().
Void setup ():es la función de arranque de Arduino, en esta inicializamos las variables a
utilizar durante nuestra programación, de modo de asignarles un espacio en la memoria del
Arduino. La función setup se ejecuta una vez durante la rutina.
Void loop (): es la función que mantiene con vida al Arduino una vez encendido. Consiste
en un bucle de repetición infinita que nos permite; leer datos de sensores, llamar a funciones,
modificar las variables definidas fuera del loop, emitir señales de respuesta al Arduino, etc.
Con estas dos funciones definidas previamente podemos arrancar la rutina del Arduino. Sin embargo,
y tal como mencionamos previamente se pueden crear otras funciones fuera de la función loop () las
que podemos llamar desde éste. De esta forma, el código queda estructurado y ordenado, lo que
permite un mayor entendimiento
Para crear funciones debemos declararlas de la siguiente manera, así por ejemplo para crear la función
alfa:
void alfa () {
estructura de la función
}
9
Para llamar a la función desde el loop () se debe llamar por su nombre, luego para llamar a la función
alfa desde el loop:
Alfa ()
Con lo descrito anteriormente, estamos en condiciones de comenzar nuestro código para trabajar con
Arduinos, en el ambiente IDE que se muestra en la Figura 1
Figura 1 - IDE Arduino para escribir códigos
10
Breve introducción a los circuitos eléctricos
Para poder empezar a trabajar con Arduinos se deben recordar conceptos básicos de electricidad
partiendo por la pregunta elemental ¿Que es un circuito eléctrico?
Un circuito eléctrico es un conjunto de componentes eléctricos tales como resistencias, fuentes,
condensadores e inductancias que conectadas entre si pueden lograr el objetivo transportar energía
eléctrica para cumplir funciones como generar, responder o modificar señales eléctricas.
Para poder elaborar un circuito eléctrico es necesario contar con los siguientes elementos principales
que son:
• Fuente de intensidad de corriente eléctrica (V) que suministra energía eléctrica necesaria con
su unidad respectiva denominada Volt.
• Flujo de intensidad de corriente electrones medida en ampere (I) y
• Resistencia o carga (R) medida en ohm
Las resistencias conectadas al circuito consumen energía que proporciona la fuente y la transforme en
energía útil, por ejemplo: encender una lámpara, realizar una acción con un dispositivo, poner en
movimiento un motor, amplificar sonidos por un altavoz, reproducir imágenes en una pantalla, etc.
Existen dos tipos de circuitos:
• Circuitos en Serie: tienen solo una trayectoria y la corriente eléctrica es la misma en cada
componente del circuito eléctrico. La desventaja que si se corta en una parte se corta todo el
circuito.
11
Figura 2 - Circuito eléctrico en serie
• Circuitos en Paralelo: La disposición de sus componentes genera más de un camino para la
corriente eléctrica por lo que si llega a fallar un camino existe el otro por donde seguirá
pasando la corriente eléctrica.
Figura 3 - Circuito eléctrico en paralelo
12
Partes fundamentales de un Arduino
Figura 4 - Partes fundamentales de un Arduino
1. Conector USB: provee la comunicación para la programación y la toma de datos, también
provee una fuente de 5VDC para alimentar al Arduino.
2. Regulador de voltaje de 5V: se encarga de convertir el voltaje ingresado por el plug 3, en un
voltaje de 5V regulado. necesario para el funcionamiento de la placa y para alimentar circuitos
externos.
3. Plug de conexión para fuente de alimentación externa: el voltaje que se suministra por aquí
debe ser directo y estar entre 6V y 18V.
4. Puerto de conexiones: constituido por 6 pines de conexión con las siguientes funciones:
i. RESET: permite resetear el microcontrolador al enviarle un cero lógico.
ii. Pin 3.3V: este pin provee una fuente de 3.3VDC para conectar dispositivos
externos como en la protoboard
iii. Pin 5V: es una fuente de 5VDC para conectar dispositivos externos.
iv. Dos pines GND: que proveen la salida de cero voltios para dispositivos externos.
v. Pin Vin: este pin está conectado con el positivo del plug 3 por lo que se usa
para conectar la alimentación de la placa con una fuente externa de entre 6 y
12VDC en lugar del plug 3 o la alimentación por el puerto USB.
13
5. Puerto de entradas análogas: Se conectan las salidas de los sensores análogos. Estos pines
solo funcionan como entradas recibiendo voltajes entre cero y cinco voltios directos.
6. Microcontrolador Atmega 328: es el microcontrolador implementado en los Arduino uno y sobre
el cual se va a programar.
7. Botón de RESET: este botón, así como el pin mencionado anteriormente, permiten resetear el
microcontrolador haciendo que reinicie el programa.
8. Pines de programación ICSP: son usados para programar microcontroladores en protoboard
o sobre circuitos impresos sin tener que retirarlos de su sitio.
9. LED ON: enciende cuando el Arduino está encendido.
10. LEDs de recepción y transmisión: estos se encienden cuando la tarjeta se comunica con el PC.
El Tx indica transmisión de datos y el Rx recepción.
11. Puerto de conexiones: está constituido por los pines de entradas o salidas digitales desde la
cero hasta la 7.
12. Puerto de conexiones: incluye 5 entradas o salidas adicionales (de la 8 a la 12), las salidas 9,
10 y 11 permiten control por ancho de pulso; la salida 13 es un poco diferente pues tiene
conectada una resistencia en serie, lo que permite conectar un led directamente entre ella y
tierra. Finalmente hay una salida a tierra GND y un pin AREF que permite ser empleado como
referencia para las entradas análogas.
13. Este led indica el estado del pin 13
14. Chip de comunicación que permite la conversión de serial a USB.
14
Encender y apagar un LED
El primer trabajo a realizar será prender un LED conectado directamente al Arduino en el pin 13. El
objetivo es manipular por primera vez estos instrumentos para sentir como un circuito trabaja en la
vida real.
No tengas a miedo a quemas las luces LED ya que estás son de muy bajo costo.
Figura 5: Encender LED con un Arduino
Debes ensamblar con cuidado la
Figura 5, teniendo especial consideración en el largo de los alambres que componen el LED.
Posteriormente debes energizar el Arduino conectándolo a tu computado. Debes ejecutar el IDE y
escribir el siguiente código:
15
Código 1 - Encender y apagar un LED
// the setup function runs once when you press reset or power the
board
void setup () {
// initialize digital pin LED_BUILTIN as an output.
pinMode (LED_BUILTIN, OUTPUT);
}
// the loop function runs over and over again forever
void loop () {
digitalWrite (LED_BUILTIN, HIGH);
// turn the LED on (HIGH is the voltage level)
delay (1000);
// wait for a second
digitalWrite (LED_BUILTIN, LOW);
// turn the LED off by making the voltage LOW
delay (1000);
// wait for a second
}
16
En tu computador el código se verá de la siguiente manera:
Figura 6 - Código escrito en IDE Arduino
Para completar tu actividad debes considerar las siguientes 3 acciones imprescindibles para que el
Arduino trabaje como circuito y pueda encender la luz de acuerdo a tus requerimientos.
1. Luego de escribir el código deberás presionar el ticket. Esto permitirá al Arduino verificar si
cada sentencia del código está bien escrita, si están todas las librerías requeridas y si existen
errores de sintaxis.
Figura 7 - botón para verificar.
17
2. Una vez revisado y aceptado, debes presionar la flecha. Esto permitirá cargar en la memoria
del Arduino el código que acabas de diseñar.
Figura 8 - Botón para cargar código.
Este código y muchos otros ejemplos básicos vienen como ejemplo y pueden ser cargado,
modificados y utilizados en otros más grande. Debes dirigirte a file/examples/01. Basics/…:
Figura 9 - Cargar códigos de ejemplo.
18
El código 1 también puede ser configurado empleando un protoboard.
“Una placa de pruebas (en inglés: protoboard o breadboard) es un tablero con orificios que se
encuentran conectados eléctricamente entre sí de manera interna, habitualmente siguiendo patrones
de líneas, en el cual se pueden insertar componentes electrónicos y cables para el armado y
prototipado de circuitos electrónicos y sistemas similares”2.
Figura 10 - Encender Led empleando Protoboard
2 Definición extraída de Wikipedia https://es.wikipedia.org/wiki/Placa_de_pruebas.
19
3 LEDS y protoboard
El siguiente desafío consiste en emplear más de un LED, una protoboard y resistencias dentro de un
circuito eléctrico que permitirá encender y apagar los LEDS en distintos tiempos.
Figura 11 - Encender 3 LEDS empleando Protoboard
Es muy importante entender y poner en práctica en este ejercicio los conceptos teóricos de circuitos
eléctricos en paralelos.
Código 2- Encender 3 LEDS
#define RED_PIN 8
#define YELLOW_PIN 10
#define GREEN_PIN 12
void setup () {
// put your setup code here, to run once:
pinMode (RED_PIN, OUTPUT);
pinMode (YELLOW_PIN, OUTPUT);
pinMode (GREEN_PIN, OUTPUT);
}
20
void loop () {
// put your main code here, to run repeatedly:
digitalWrite (RED_PIN, HIGH);
delay(3000);
digitalWrite (YELLOW_PIN, HIGH);
delay(1000);
digitalWrite (RED_PIN, LOW);
digitalWrite (YELLOW_PIN, LOW);
digitalWrite (GREEN_PIN, HIGH);
delay(3000);
digitalWrite (GREEN_PIN, LOW);
delay(500);
digitalWrite (GREEN_PIN, HIGH);
delay(500);
digitalWrite (GREEN_PIN, LOW);
delay(500);
digitalWrite (GREEN_PIN, HIGH);
delay(500);
digitalWrite (GREEN_PIN, LOW);
delay(500);
digitalWrite (GREEN_PIN, HIGH);
delay(500);
digitalWrite (GREEN_PIN, LOW);
digitalWrite (YELLOW_PIN, HIGH);
delay (1000);
digitalWrite (YELLOW_PIN, LOW);
}
21
Sensores y transmisión de datos
22
Medición de temperatura con termistor
Se incorporará una dificultad al siguiente código, ya que por medio de un termistor (un medidor de
temperatura) y un cálculo matemático basado en la resistencia agregada al circuito, se calculará la
temperatura ambiente. Para ello es necesario incluir una resistencia de 10 kom
Figura 12 - Configuración Arduino Termistor
Figura 13 - Relación Tempreatura y Resistencia
23
Código 3 - Medición de Temperatura
#include <math.h>
//Declaración de Variables y Librerías
const int Rc = 10000; //valor de la resistencia
const int Vcc = 5;
const int SensorPIN = A0; //Pin donde va instalado el
sensor al arduino
float A = 1.11492089e-3;
float B = 2.372075385e-4;
float C = 6.954079529e-8;
float K = 2.5;
//factor de disipación en mW/C
void setup () {
Serial.begin(9600);
}
void loop () {
float raw = analogRead (SensorPIN);
float V = raw / 1024 * Vcc;
float R = (Rc * V) / (Vcc - V);
float logR = log(R);
float R_th = 1.0 / (A + B * logR + C * logR * logR *
logR);
float kelvin = R_th - V*V/ (K * R) *1000;
float celsius = kelvin - 273.15;
Serial.print("T = ");
Serial.print(celsius);
Serial.print("C\n");
Delay (2500);
}
24
Lector de gas y envío de datos vía Bluetooth
En el siguiente ejercicio se construirá un sistema que sea capaz de detectar gases en un perímetro determinado,
enviando la información capturada vía Bluetooth a cualquier estación de recepción que cuente con dicha
tecnología. Se empleará la aplicación JBWAVE que se encuentran en las plataformas IOS.
Figura 14 - Elementos para construir circuito de detección de gases.
1. Se debe realizar la conexión de la figura 15, preocupándose de conectar a los pines 3 y 2 las
conexiones TXD y RXD del Bluetooth que serán los encargados de recibir y enviar la
información.
2. Conectar el sensor MQ-6 a los pines de 5V, GND y al pin 6, en este caso la información que
nos entregara solo serán 1 o 0 ósea si existe o no presencia de gas natural.
3. Preocuparse que ambos elementos estén conectados a 5V dado a su requerimiento energético.
Arduino Uno Sensor MQ-6
Bluetooth HC-06 7x Jumper
25
Figura 15 - Conexión de sensor de gases
3. Descargar la aplicación JBWAVE y enlazar el Bluetooth del Arduino a su celular.
4. Abrir la terminal del Bluetooth del teléfono y ver como se muestran los datos.
Figura 16 - Aplicación para recibir información Blueetooth
26
Código 4 - Presencia de gases y transmisión de datos vía Bluetooth
#include <SoftwareSerial.h>
int pin_mq = 4;
const int pinBuzzer = 6;
SoftwareSerial blue (2, 3);
void setup () {
Serial.begin(9600);
PinMode (pin_mq, INPUT);
blue.begin (9600);
blue.println ("Conectado");
}
void loop () {
//Leemos el sensor (0 si identifica gas, 1 si no
identifica)
boolean mq_estado = digitalRead(pin_mq);
if (mq_estado) {
Serial.println("Sin presencia de Gas Natural");
blue.println ("Sin presencia de Gas Natural");
}
else {
Serial.println("Gas Natural Detectado");
blue.println ("Gas Natural Detectado");
tone (pinBuzzer, 440);
}
//esperamos 1 segundo para reinciar lectura
delay (1000);
}
27
Envío de datos mediante antena NRF24
No sólo existe el Bluetooth como medio de transmisión de datos entre dos Arduinos. Es posible conectar
dos o más de ellos mediante antenas. En este caso en particular se empleará la NRF24, que tiene un
alcance de 20m.
Figura 17 - Componentes para transmisión de datos vía antena NRF24
1. Se conectar cada Arduino a una antena mediante los jumpers. (Uno se comportará como
Emisor y otro como Receptor). Conectar ambos de la siguiente forma:
Figura 18 - Conexión de antena NRF24
2. Conectar los dos Arduinos y colocar los códigos de emisor y receptor a cada Arduino
(Entregados y explicados más abajo).
3. Evidenciar los datos en tu computador a través del Monitor serie del Arduino.
Arduino Uno NRF24 Jumpers
28
El resumen de conexión de la antena NRF 24 al Arduino es el siguiente:
1.GND
GND
2.VCC
PIN 3.3V
3.CE
PIN 9
4.CSN
PIN 10
5.SCK
PIN 13
6.MOSI
PIN 11
7.MISO
PIN 12
Nota: Es relevante destacar y no olvidar que la energía entregada a la Antena debe ser de 3.3 Volt.
Código 5 - Receptor antena NRF24
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
//Inicializamos las librerías a utilizar
#define CE_PIN 9
#define CSN_PIN 10
//Declaremos los pines CE y el CSN
byte dirección [5] ={'c','a','n','a','l'};
//Variable con la dirección del canal por donde se va a
transmitir
RF24 radio (CE_PIN, CSN_PIN);
//creamos el objeto radio (NRF24L01)
float datos [3];
//creamos el vector con los datos a enviar
void setup () {
radio.begin ();
//inicializamos el NRF24L01
Serial.begin (9600);
//inicializamos el puerto serie
radio.openWritingPipe (direccion);
//Abrimos un canal de escritura
}
29
void loop () {
datos [0]= analogRead (0) * (5.0 / 1023.0);
datos [1]= millis ();
datos [2]=3.14;
//inicializamos el vector de datos.
bool ok = radio.write (datos, sizeof(datos));
//se envían los datos.
if(ok) {
Serial.print ("Datos enviados: ");
Serial.print (datos [0]);
Serial.print (" , ");
Serial.print (datos [1]);
Serial.print (" , ");
Serial.println (datos [2]);
//reportamos por el puerto serial los datos enviados
}
else {
Serial.println("no se ha podido enviar");
}
delay (1000);
// damos 1 segundo para volver a la rutina
}
30
Los datos enviados pueden observarse de la siguiente manera:
Figura 19 - Representación gráfica de envío de datos con antena NRF24
Código 6 - Emisor antena NRF24
#include <SPI.h>
#include <Ethernet.h>
// cargamos las librerías a utilizar
byte mac [] = { 0xBE, 0xEF, 0x8F, 0xB4, 0x6B, 0x11 };
//informamos la MAC address de la placa arduino.
//La MAC address (Media Access Control) es un identificador
de 48 bits (6 bloques de dos caracteres hexadecimales (4
bits)) que corresponde de forma única a una tarjeta o
dispositivo de red.
EthernetClient client;
// creamos el objeto cliente de la librería Ethernet
void setup () {
Serial.begin(9600);
// inicializamos la librería serial:
if (Ethernet.begin (mac) == 0) {
// inicializamos la conexión ingresando la MAC del arduino
31
Serial.println ("Failed to configure Ethernet using DHCP");
// sino encuentra conexión se interrumpe la transmisión
for (;;)
;
}
Serial.println (Ethernet.localIP());
// Si hay conexión nos entrega la IP de conexión en consola
}
void loop () {
//se deja en blanco ya que solo necesitamos un dato
}
El envío exitoso de datos entre ambos Arduinos por medio de las antenas NRF24 permitirá ver la
información fluyendo de un lado a otro de la siguiente manera:
Figura 20 - Representación gráfica de recepción de datos con antena NRF24
32
Visualización Gráfica
33
Conexión a base de datos SQL.
Los Arduinos son capaces de recolectar información desde sensores y los resultados pueden ser
observados en el monitor que Arduino IDE posee.
También es posible guardar los resultados en variables, conectarse a un servidor y almacenar la
información en bases de datos que posteriormente son consultadas desde páginas web en cualquier
browser.
Para ello, en cualquier código de Arduino se deben incluir las siguientes sentencias en el encabezado,
en el void setup () y en void loop ().
Los códigos deben incluir en el encabezado junto a otras librerías son:
#include <Ethernet.h>
#include <EthernetClient.h>
#include <EthernetServer.h>
#include <EthernetUdp.h>
#include <SPI.h>
#include <Wire.h>
Luego de las Librerías se debe incluir:
byte mac [] = { 0xBE, 0xEF, 0xA7, 0x02, 0x86, 0x20};
// MAC Address
// Informamos los parametros de conexión IP, MAC address
byte ip [] = { 192,168,1,167};
// Arduino IP Address
byte server [] = {192,168,1,1};
// Se informa el IP del servidor si trabajamos en ambiente
local. O es IP para local Host o es Página web.
char server [] = "www.paginaweb.com";
//Si corresponde a un ambiente web se informa el
webhosting. O es IP para local Host o es Página web.
EthernetClient client;
// construimos el objeto client
34
En la sección void setup () se deben agregar las siguientes:
Serial.begin(9600);
// inicializamos el Puerto serial
Ethernet.begin(mac, ip);
// inicializamos la vía de transmisión de datos
En la sección void Loop () se deben agregar las siguientes:
Serial.println("Connecting...");
// Comenzamos el proceso de envió de datos
if (client.connect (server, 80)>0) {
//si hay conexión, entonces enviamos los datos
client.print ("GET /carpetaserver/iot.php?");
//realizamos el envió de datos por GET
client.print ("valor=");
client.print (celsius);
client.println (" HTTP/1.0");
client.println ("Host: www.paginaweb.com");
client.println ("User-Agent: Arduino 1.0");
client.println ();
Serial.println ("Connected");
}
// si no hay conexión informamos en consola
else {
Serial.println("Conection Fail");
}
client.stop();
client.flush();
// detenemos la conexión
Es muy importante entender que la conexión es a un localhost, el cual emplea IP de acceso en una
misma red WIFI para los dispositivos que se quieran conectar a ella, o un host de página web con
dirección. No pueden ser ambas al mismo tiempo.
35
En el servidor al cual se hace referencia, ya sea un localhost con su carpeta destinada a almacenar la
información como un servidor en la web, deben contener una carpeta que contenga los siguientes dos
archivos php de conexión. El Arduino por medio del GET incluido en la sección void Loop () hace
referencia a ellos, llamándolos, copiando la variable capturando por el sensor y almacenando dicho
dato en una tabla SQL que se tiene que tener previamente configurada.
Código 7 - Archivo iot.php para conexión de arduino con base de datos
<? php
require ("config.php");
// Importamos la configuración que permite el acceso a la
base de datos.
$valor = mysqli_real_escape_string ($con, $_GET['valor']);
// Leemos los valores que nos llegan por GET
$query = "INSERT INTO nombretabla (campotabla)
VALUES('".$valor."')";
// Esta es la instrucción para insertar los valores
mysqli_query ($con, $query);
mysqli_close ($con);
// Ejecutamos la instrucción
?>
36
Código 8 - Archivo Config.php para acceder a base de datos.
<? php
$dbhost = "localhost";
$dbuser = "user";
$dbpass = "password";
$dbname = "databasename";
// Se entregan todas las credenciales que permiten el
acceso a la base de datos y a almacenar registros en la
base de datos creada y seleccionada
$con = mysqli_connect ($dbhost, $dbuser, $dbpass, $dbname);
// Se ejecuta la acción y se ingresa a la base de datos por
petición del archivo iot.php
?>
37
Sensor Termistor con conexión a base de datos para despliegue web
El siguiente ejercicio busca unificar criterios visto a lo largo de este tutorial, creando una configuración
que tenga un sensor y capture datos de su entorno, almacene datos y luego los aloje en un servidor
web para su visualización por medio de una página web.
Emplearemos el caso del Termistor e incluiremos las sentencias que permiten la conexión y que fueron
detalladas más arriba.
#include <math.h>
#include <Ethernet.h>
#include <EthernetClient.h>
#include <EthernetServer.h>
#include <EthernetUdp.h>
#include <SPI.h>
#include <Wire.h>
//se cargan las librerías necesarias
byte mac [] = { 0xBE, 0xEF, 0xA7, 0x02, 0x86, 0x20};
// Configuración del Ethernet Shield
// informamos la MAC address del arduino
byte ip [] = { 192,168,1,167};
// informamos la IP del arduino. En este caso sólo se
emplea un ejemplo
char server [] = "www.paginaweb.com";
// informamos el nombre del servidor web. Recuerda que
incluyes la IP de tu localhost o la página web. Nunca
ambos.
EthernetClient client;
// construimos el objeto client.
const int Rc = 10000;
const int Vcc = 5;
const int SensorPIN = A0;
float A;
float B;
float C;
float K;
float raw;
float V;
float R;
float logR;
38
float R_th;
float kelvin;
float celsius;
// creamos las variables del sensor
void setup () {
Serial.begin(9600);
//incializamos el serial
Ethernet.begin(mac, ip);
// Inicializamos el Ethernet Shield
A = 1.11492089e-3;
B = 2.372075385e-4;
C = 6.954079529e-8;
K = 2.5; //factor de disipación en mW/C
// inicializamos las variables del sensor
}
void loop () {
delay (10000);
//esperamos 10 segundo para dar espacio a la transmisión
raw = analogRead(SensorPIN);
V = raw / 1024 * Vcc;
R = (Rc * V) / (Vcc - V);
logR = log(R);
R_th = 1.0 / (A + B * logR + C * logR * logR * logR);
kelvin = R_th - V*V/ (K * R) * 1000;
celsius = kelvin - 273.15;
//leemos la temperatura en el sensor
Serial.print("T = ");
Serial.print(celsius);
Serial.print("C\n");
//Se imprimen los resultados en visualizador IDE Arduino.
39
Serial.println("Connecting...");
//Proceso de envío de muestras al servidor.
if (client.connect (server, 80)>0) {
client.print ("GET /carpetaserver/iot.php?");
//Si hay conexión con servidor entonces transmitimos los
datos por GET.
client.print ("valor=");
client.print (celsius);
client.println (" HTTP/1.0");
client.println ("Host: www.paginaweb.com");
client.println ();
client.println ("User-Agent: Arduino 1.0");
Serial.println("Conectado");
}
else {
Serial.println("Fallo en la conexión");
//Si no hay conexión con servidor entonces tendremos ese
mensaje.
}
client.stop ();
client.flush ();
// detenemos la conexión
}
40