MÓDULO DE RELEVADORES

MÓDULO DE RELEVADORES: DIAGRAMA ESQUEMÁTICO

MÓDULO DE RELEVADORES: CONEXIÓN ARDUINO
Arduino + Sensor Ultrasónico
 Arduino + Sensor Ultrasónico

La velocidad del sonido es 340 m/Seg, lo cual equivale a 29 µSeg/cm

µSeg /29 / 2 ==➔ µSeg/58 =➔ Resultado en CM
µSeg /74 / 2 ==➔ µSeg/148 =➔ Resultado en INCH
Arduino + DHT11 Sensor Humedad-Temp
Arduino + DHT11 Sensor Humedad-Temp
Arduino + DHT11 Sensor Humedad-Temp
Arduino + DHT11 Sensor Humedad-Temp
Arduino + DHT11 Sensor Humedad-Temp
Arduino + Sensor Digital DS18B20
Arduino + Sensor Digital DS18B20
Arduino + Sensor Digital DS18B20
Arduino + Red Sensores Digital DS18B20
VOLTAGE vs TEMPERATURA: TMP36
CONEXIÓN EN ARDUINO UNO
Conexión Arduino + MQ-7
SENSOR DE GAS LPG MQ-2
 SENSOR DE GAS LPG MQ-2

Para determinar la concentración de gases necesitaremos la recta que la

aproxima, para lo cual debemos seleccionar dos cualesquiera de la grafica de
comportamiento anterior, por lo cual:

P0 = { X0, Y0} y P1 = {X1, Y1}

Resultando la recta:

Y = A*x + B Ecuación 1
 SENSOR DE GAS LPG MQ-2
Donde:
Y1 − Y0 Ecuación 2
A=
X1 − X0

Despejando B de ecuación 1: 𝐵 = 𝑌0 − 𝐴 ∗ 𝑋0

Rs = Resistencia del sensor

Ro = Resistencia del sensor (10 en KΩ a 1000ppm)
Rs/Ro = Razón de sensibilidad del sensor (5 en KΩ para el módulo electrónico utilizado)
RL = Resistencia de salida o carga
A = Pendiente de la recta
B = Coordenada abscisa de la recta.

Seleccionando de la gráfica:
X0 = 200 Y0= 1.7 ; X1= 10000 Y1=0.28 𝑙𝑜𝑔10 [0.28] − 𝑙𝑜𝑔10 [1.7]
A=
𝑙𝑜𝑔10 [10,000] − 𝑙𝑜𝑔10 [200]
 SENSOR DE GAS LPG MQ-2
Calculando Pendiente y coordenada de Abscisa:

−0.552842 − 0.230449 −0.783291

A= = = -0.461038747
4 − 2.30103 1.69897

𝐵 = 0.230449 − [−0.461038747 ∗ 2.30103]

𝑩 = 𝟏. 𝟐𝟗𝟏𝟑𝟏𝟑

𝒑𝒑𝒎 = 𝟏𝟎𝑨∗ 𝒍𝒐𝒈 𝑹𝒔/𝑹𝒐 +𝑩

 CODIGO EJEMPLO MQ-2
const int MQ_PIN = A0; // Pin del sensor // Obtener la resistencia promedio en N muestras
const int RL_VALUE = 5; // Resistencia RL del modulo en Kilo ohms float readMQ(int mq_pin)
const int R0 = 10; // Resistencia R0 del sensor en Kilo ohms {
float rs = 0;
// Datos para lectura multiple
for (int i = 0;i<READ_SAMPLE_TIMES;i++) {
const int READ_SAMPLE_INTERVAL = 100; // Tiempo entre muestras
const int READ_SAMPLE_TIMES = 5; // Numero muestras rs += getMQResistance(analogRead(mq_pin));
delay(READ_SAMPLE_INTERVAL);
// Ajustar estos valores para vuestro sensor según el Datasheet }
// (opcionalmente, según la calibración que hayáis realizado) return rs / READ_SAMPLE_TIMES;
const float X0 = 200; }
const float Y0 = 1.7;
const float X1 = 10000; // Obtener resistencia a partir de la lectura analogica
const float Y1 = 0.28;
float getMQResistance(int raw_adc)
{
// Puntos de la curva de concentración {X, Y}
const float punto0[] = { log10(X0), log10(Y0) }; return (((float)RL_VALUE / 1000.0*(1023 - raw_adc) / raw_adc));
const float punto1[] = { log10(X1), log10(Y1) }; }

// Calcular pendiente y coordenada abscisas // Obtener concentracion 10^(coord + scope * log (rs/r0)
const float scope = (punto1[1] - punto0[1]) / (punto1[0] - punto0[0]); float getConcentration(float rs_ro_ratio)
const float coord = punto0[1] - punto0[0] * scope; {
return pow(10, coord + scope * log(rs_ro_ratio));
void setup()
}
{
Serial.begin(9600);
}

void loop()
{
float rs_med = readMQ(MQ_PIN); // Obtener la Rs promedio
float concentration = getConcentration(rs_med/R0); // Obtener la concentración

// Mostrar el valor de la concentración por serial

Serial.println("Concentración: ");
Serial.println(concentration);
}
Conexión Arduino + MQ-2
SINCRONIA DE BUS EN I2C
* Esun protocolo de comunicación diseñado par permitir que múltiples
dispositivos integrados (Esclavos) se comuniquen con uno o mas
dispositivos centrales (Maestros).
* Al igual que algunos otros protocolos, está pensado para
comunicaciones con dispositivos a corta distancia y solo utiliza dos
cables para la comunicación.
 *

* A través de los dos cables del protocolo I2C se pueden

conectar hasta 1008 dispositivos esclavos.
* I2C puede soportar sistemas con múltiples maestros donde los
maestros no pueden comunicarse entre sí y deben de tomar
su turno para usar el bus.
* La velocidad de transferencia de datos varia entre los 100khz
o 400khz. Por cada 8 bits de datos transmitidos, se debe
transmitir un bit de metadatos para conocer si se recibió
correctamente.
* Cada bus contiene dos señales: SDA y SCL. La primera es la
señal de datos y la segunda es la señal de reloj para la
sincronización. La señal de reloj es generada por el maestro
que esta haciendo uso del bus.
La comunicación por I2C es más compleja que con UART o SPI. La
señalización debe adaptarse al protocolo para que los
dispositivos conectados al bus reconozcan los datos como una
comunicación I2C válida.
Arduino + I2C
Arduino + I2C RED
Arduino + I2C Topología
Arduino + Real Time Clock

Dirección EsclavoI2C DS1307 = 1101 000R

D0 = Para operaciones de Escritura
D1 = Para operaciones de Lectura
Tabla RTC DS1307
Operaciones de bus en el RTC DS1307Arduino + Real Time Clock
Operaciones de bus en el RTC DS1307Arduino + Real Time Clock
I2C Diagrama Conexión Real Time Clock DS1307
CONEXIÓN LCD-ARDUINO A 4 BITS
CONEXIÓN LCD-mC A 8 BITS
CONEXIÓN LCD-ARDUINO A 4 BITS
CONTROLADOR LCD I2C
CONTROLADOR LCD I2C
Diagrama esquemático
CONTROLADOR LCD I2C
CONEXIÓN ARDUINO
CONTROLADOR LCD I2C
CONEXIÓN ARDUINO
 LCD OLED I2C CONEXIÓN ARDUINO

Nota: usar software Image2LCD para convertir imagen «Paint» a 128x64 e insertar código en Sketch Arduino
COMUNICACIÓN <<SPI>>
 TFT 1.8” COLOR SPI CONEXIÓN ARDUINO

Nota: usar software Image2LCD para convertir imagen «Paint» a 128x160 e insertar código en Sketch Arduino
 TFT 1.8” COLOR SPI CONEXIÓN ARDUINO

Nota: usar software Image2LCD para convertir imagen «Paint» a 128x160 e insertar código en Sketch Arduino
 TFT 1.8” COLOR SPI CONEXIÓN ARDUINO

Nota: usar software Image2LCD para convertir imagen «Paint» a 128x160 e insertar código en Sketch Arduino
 Librería TFT v1.0.5 métodos
Adafruit_ST7735(uint8_t CS, uint8_t RS, uint8_t RST);

fillScreen(uint16_t color);

setRotation(uint8_t r);

setCursor(int16_t x, int16_t y);

setTextColor(uint16_t c);

setTextColor(uint16_t c, uint16_t bg);

setTextSize(uint8_t s);

background(uint8_t red, uint8_t green, uint8_t blue);

background(color c);
 Librería TFT v1.0.5 métodos
fill(uint8_t red, uint8_t green, uint8_t blue);

fill(color c);

noFill();

stroke(uint8_t red, uint8_t green, uint8_t blue);

stroke(color c);

noStroke();

text(const char * text, int16_t x, int16_t y);

textSize(uint8_t size);

uint8_t getRotation(void);

virtual uint16_t newColor(uint8_t red, uint8_t green, uint8_t blue);

 Librería TFT v1.0.5 métodos
drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);

drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);

drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);

drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color)

drawCircleHelper(int16_t x0, int16_t y0,int16_t r, uint8_t cornername, uint16_t color)

fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color)

fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color)

drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);

fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);

rect(int16_t x, int16_t y, int16_t width, int16_t height)

rect(int16_t x, int16_t y, int16_t width, int16_t height, int16_t radius)

triangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3)

fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);

drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);

fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,int16_t x2, int16_t y2, uint16_t color);

drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size);

drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color)

circle(int16_t x, int16_t y, int16_t r)

point(int16_t x, int16_t y)

line(int16_t x1, int16_t y1, int16_t x2, int16_t y2)

quad(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, int16_t x4, int16_t y4)
 Librería TFT v1.0.5 métodos

COLORES DEFINIDOS EN LA LIBRERÍA <<Adafruit_GFX.h>>

#define ST7735_BLACK 0x0000

#define ST7735_BLUE 0x001F
#define ST7735_RED 0xF800
#define ST7735_GREEN 0x07E0
#define ST7735_CYAN 0x07FF
#define ST7735_MAGENTA 0xF81F
#define ST7735_YELLOW 0xFFE0
#define ST7735_WHITE 0xFFFF
 TFT método MEDIDOR ANALÓGICO
Coord X (columnas)

Punto 2

Coord Y (filas)

radio
(Xcentral , Ycentral)

Punto 1

Mapear valor de la variable en rango de 0 – 90 grados.

ángulo = 0 – 90 grados; angulo = map(valor, 0, 1500, 0, 90)

Para medidor de media circunferencia o 180 grados realizar:

Si ángulo < 45° ; Entonces sumar 135°

Si no (ángulo >= 45); Entonces restar 45°
 TFT método MEDIDOR ANALÓGICO

Coordenadas Columnas: X1= Sen(2*angulo*2π/360)

Donde: 2π/360 = 0.017453

X1= Sen(2*angulo*0.17453)
Por tanto:
X1= Sen(angulo*0.034906)

Coordenadas Filas: Y1= Cos(2*angulo*2π/360)

Y1= Cos(angulo * 0.034906)

APLICAR EN FUNCION PARA SU GRAFICACION

drawLine(Xcentral , Ycentral, [Xcentral+ radio * X1], [Ycentral - radio * Y1], color)

Radio = longitud de la línea del medidor

 INTERRUPCIONES EN ARDUINO

Interrupción.- Es un mecanismo que permite asociar una función a la

ocurrencia de un determinado evento. Esta función de callback asociada
se denomina ISR (Interruption Service Rutine).

En programación, una interrupción es una señal recibida por el

procesador o MCU, para indicarle que debe «interrumpir» el curso de
ejecución actual y pasar a ejecutar código específico para tratar esta
situación.
 MECANISMO DE INTERRUPCION

1. Terminar la ejecución de la instrucción máquina en curso.

2. Salvar el estado del procesador (valores de registros y flags) y el valor

del contador de programa en la pila, de manera que en la CPU, al
terminar el proceso de interrupción, pueda seguir ejecutando el
programa a partir de la última instrucción.

3. La CPU salta a la dirección donde está almacenada la rutina de

servicio de interrupción (Interrupt Service Routine, o abreviado ISR) y
ejecuta esa rutina que tiene como objetivo atender al dispositivo que
generó la interrupción.

4. Una vez que la rutina de la interrupción termina, el procesador restaura

el estado que había guardado en la pila en el paso 2 y retorna al
programa que se estaba usando anteriormente.
MECANISMO DE INTERRUPCION
MECANISMO DE INTERRUPCION
MECANISMO DE INTERRUPCION
TABLA DE INTERRUPCIONES AVR
MECANISMO DE INTERRUPCION EN ARDUINO
REGISTROS DE INTERRUPCION EN AVR
Arduino + Xbee Shield
Arduino + Xbee Shield
MOTORES DE D.C.
Motor de Corriente Directa
Motor de Corriente Directa: Operación con puente H
Puente H Bipolar
Operación: Giro a la Derecha
Operación: Giro a la Izquierda
Operación: Freno en Baja
Operación: Freno en Alta
Operación: Freno por Inercia
 Operación: Freno por Inercia
# Q4 Q3 Q2 Q1 Resultado
1 Off Off Off Off Libre
2 Off Off Off On Freno a la derecha
3 Off Off On Off Freno a la izquierda
4 Off Off On On Corto circuito
5 Off On Off Off Freno a la izquierda
6 Off On Off On Freno ambas direccione (en bajo)
7 Off On On Off Giro a la derecha
8 Off On On On Corto circuito
9 On Off Off Off Freno a la derecha
10 On Off Off On Giro a la izquierda
11 On Off On Off Freno ambas direccione (en alto)
12 On Off On On Corto circuito
13 On On Off Off Corto circuito
14 On On Off On Corto circuito
15 On On On Off Corto circuito
16 On On On On Doble corto circuito
Puente H: L298
Puente H: L298
MOTOR D.C. 130 con Encoder óptico.
Conexión encoder óptico motor DC-130
Motor TIPO 2
Motor TIPO 2
Motor TIPO 2
MOTOR con Encoder DC-380
MOTOR con Encoder DC-380
Puente H: L298
DRIVER L298: Diagrama esquemático
Conexión Arduino: 1 Motor
Conexión con Arduino: 2 Motores
Conexión con Arduino: 2 Motores (a 5 volts desde Arduino)
SERVOMOTORES

❑ Una clase especial de motores son

conocidos como hobby o RC motors
❑ Esos motores son ampliamente utilizados
en carros de radio-control, aviones y botes
❑ La velocidad de rotación de este tipo de
motor es de aproximadamente de 0.2 seg.
para 60° de recorrido angular
SERVOMOTORES

❑ Los servomotores consisten

principalmente en:
➢ Un pequeño motor de DC
➢ Un reductor de engranaje
➢ Un potenciometro
➢ Una tarjeta de control

❑ Estos sevomotores cuentan con tres

cables que son:
➢ Vcc (4.8 ~ 7.0Vdc)
➢ GND
➢ Señal de control (PWM)
SERVOMOTORES
❑ El ancho de pulso de la señal de control va de
aproximadamente 0.7 ms hasta los 2.3 ms.
❑ En 0.7 ms, el servo esta en un extremo de su rango de
movimiento, mientras que en los 2.3 ms esta en el otro
extremo.
❑ En 1.5 ms se encuentra en el punto medio del rengo de
movimiento
❑ La mayoría de los servos tienen un rango de
movimiento de ±90°
SERVOMOTOR SG-90
ESPECIFICACIONES SERVOMOTORES
ESPECIFICACIONES SERVOMOTORES
SERVOMOTORES CONTROL
SERVOMOTORES TORQUE
SERVOMOTORES: CONEXIÓN ARDUINO
SERVOMOTORES: CONEXIÓN CON ARDUINO
 MOTOR PASO A PASO

❑ Un motor a pasos puede ser

clasificado como un motor de DC,
debido a que es operado por
voltajes de corriente directa, pero
su funcionamiento y construcción es
distinta a la de un motor de CD

❑ Los motores paso a paso, como su

nombre sugiere, pueden moverse en
pequeños incremento angulares, o
pasos, que van desde los 0.9° hasta
los 90° por paso, dependiendo de la
construcción del motor y como sea
manejado
MOTOR PASO A PASO
 MOTOR PASO A PASO

Hay tres tipos de motores paso a paso:

➢ los de imán permanente (PM, permanent
magnet)
➢ reluctancia variable (VR, variable
reluctance)
➢ híbridos.
Las configuraciones difieren principalmente
en la construcción del rotor
FUNCIONAMIENTO
FUNCIONAMIENTO
TIPOS DE MOTORES A PASOS
 SECUENCIA DE CONTROL: MOTOR BIPOLAR
Un motor paso a paso BIPOLAR necesita invertir la corriente
que circula por sus bobinas en una secuencia determinada
Para provocar el movimiento del eje.
 MOTOR BIPOLAR: STH-39D1126-06
CARACTERISTICAS MOTOR:
BIPOLAR HIBRIDO.
Step: 1.8°por paso.
Voltaje: 6.15 Vdc.
Amperes: 1.5 Amp.
NEMA 16.

Conexión:
Fase A: +A naranja, -A café.
Fase B: +B rojo, -B amarillo.
Diámetro motor: 39*39mm
Altura del motor : 30mm
Longitud del eje: 20mm
CONEXIÓN ARDUINO: MOTOR BIPOLAR
CONTROL: MOTOR BIPOLAR
Diagrama Esquemático A4988
Conexión Mínima Pololu A4988
A4988 Driver Resolution
CONEXIÓN ARDUINO + A4988
CONEXIÓN ARDUINO + A4988
Arduino + 3 A4988 Drivers
Arduino + 3 A4988 Drivers
MOTOR UNIPOLAR 28BYJ-48 5VDC: CONEXIÓN ARDUINO
SECUENCIA DE CONTROL: MOTOR UNIPOLAR
Existen 3 métodos o secuencias diferentes para controlar
Un motor a pasos UNIPOLAR.

Simple o Wave Drive:

Es una secuencia donde se activa una bobina a la vez. Lo cual hace que
el motor tenga un paso muy suave y a su vez menor fuerza o torque.
 SECUENCIA DE CONTROL: MOTOR UNIPOLAR

Normal:
Es la secuencia mas utilizada y recomendada por los fabricantes. Con esta
Secuencia, el motor avanza un paso por vez y siempre hay 2 bobinas activas.
Con lo cual se obtiene un mayor torque y fuerza de retención.
 SECUENCIA DE CONTROL: MOTOR UNIPOLAR

Medio Paso:

En esta secuencia se activan

primero 2 bobinas y luego 1, así
sucesivamente.

Esto provoca que el motor avance la

mitad del paso real, lo cual se
traduce
En un giro mas suave y preciso.
MOTOR UNIPOLAR 28BYJ-48 5VDC: CONEXIÓN ARDUINO
CONTROL MOTOR UNIPOLAR: 28BYJ-48 5VDC
MOTOR UNIPOLAR: 28BYJ-48 5VDC
ESQUEMÁTICO CONTROLADOR MOTOR: 28BYJ-48 5VDC
CONTROL MOTOR UNIPOLAR: SECUENCIA
SENSOR ILUMINACION: FOTORRESISTENCIA
SENSOR ILUMINACION: FOTORRESISTENCIA
MÓDULO DE COMUNICACIÓN: BLUETOOTH
 Wireless Regional Area Network

WWAN IEEE 802.22

19 Mbps
Mobile Broadband Wireless Access

IEEE 802.20
80 Mbps 34Mbps y 1 Gbps
WMAN
Rango

WiMax
IEEE 802.16
Zigbee
WLAN WiFi
802.15.4
15.4c 802.11
Bluetooth 802.15.3
WPAN 802.15.1 802.15.3c
Ultra Wide Band

0.01 0.1 1 10 100 1000

Velocidad (Mbps)
 Parámetros WiMAX WLAN IEEE BlueTooth
IEEE 802.16 802.11 IEEE 802.15.1
Banda de 2-11 Ghz 2.4 Ghz 800-915 Mhz,
Frecuencia 5.0 Ghz 2.4 Ghz.

Rango de cobertura 60 Km. +100 Mts. -10 Mts.

Aprox. 100 mts.
(alto consumo de energía)

Velocidad de 34 Mbps 300 Mbps. 750 Kbps. a 1 Mbps

Transferencia 1.0 Gbps

Usuarios que Miles Docenas 7

soporta (32 usuarios)
MÓDULO DE COMUNICACIÓN: TOPOLOGÍA
MÓDULO DE COMUNICACIÓN: CONEXIÓN ARDUINO
MÓDULO DE COMUNICACIÓN HC-05: ESQUEMÁTICO
PARAMETROS DE PROGRAMACIÓN: HC-05
PARAMETROS DE PROGRAMACIÓN: HC-05
PARAMETROS DE PROGRAMACIÓN: HC-05
MÓDULO BLUETOOTH: SPP-C
MÓDULO SPP-C: COMANDOS
MÓDULO DE COMUNICACIÓN: WiFi
COMANDOS GENERICOS:

AT Prueba la comunicación

AT+RST Reset por software

AT+GMR Obtener versión firmware

AT+CWMODE=1 (Configura Modo de trabajo 1=Sta, 2=AP, 3= AP+Sta)

CONFIGURAR COMO AP (AT+CWMODE=2 o 3)

AT+CWSAP="MICROS","PASSWORD",CANAL,ENC
Canal = 1 al 11
enc= 0-Open, 1-WEP, 2-WPA_PSK, 3-WPA2_PSK, 4-WPA_WPA2_PSK
(SOLO AL CONFIGURAR COMO AP, AT+CWMODE=2)

*Este comando en modo SET, requiere un Reset (AT+RST)

AT+CIFSR (Proporciona dir IP asignada al módulo)

AT+CWLIF (Proporciona lista de IP´s de dispositivos asociados al módulo cuando esta en modo AP)
CONFIGURAR COMO ESTACION: (AT+CWMODE=1, Modo STA)
AT+CWLAP (Lista de AP´s en la cercanía)

AT+CWJAP="micros","12345678“

AT+CWQAP (Desconectarse del AP)

AT+CIPMUX=1 (0= Simple, 1=Multiconexión)

AT+CIPSTART=<Id>,"tipo","dir. IP",puerto

AT+CIPSTART=1,"UDP","192.168.0.109",9000 (Conexión UDP)

AT+CIPSTART=2,"TCP","192.168.0.109",9002 (Conexión Cliente TCP)

AT+CIPSERVER=1,9750 (Inicia serverTCP en puerto=9750) Solo opera EN MODO MULTI-CONEXION, +CIPMUX=1

AT+CIPSTO=segundos (Establece timeout serverTCP en segundos)

AT+CIPSTATUS (Proporciona los datos de conexiones activas)

+CIPSTATUS:1,"UDP","192.168.0.109", 9000, 20324, 0
1 = Id conexión, UDP = tipo conexión protocolo
192.168.0.109 = Dir IP remoto, 9000 = Puerto Remoto, 20324 = Puerto Local (Wee/Wifi)
0 = Tipo Conexión ( 0= Cliente, 1=Server)

AT+CIPCLOSE=<Id_Conexion> (Cierra conexión dada por "Id")

AT+CIFSR (Obtiene la dir IP del módulo)

TRANSMISION DE DATOS POR ALGUNA CONEXION ESTABLECIDA

AT+CIPSEND=<Id conexión>,<longitud Datos>

AT+CIPSEND=0,22 (envía por socket 0, 22 bytes datos)

Los datos son entrados después de recibir símbolo ">")

HOLA XPERIA ZL SALUDOS (paquete de 22 bytes de datos)

RECEPCION DE DATOS EN EL MÓDULO:

+IPD, <Id>, <len>: <data>

Id= Conexión de entrada de datos,

len = Tamaño de paquete de datos recibido
data = paquete de datos útil
TRANSMISION DE DATOS POR CONEXION CON THINGSPEAK:

AT+GMR

AT+CWMODE=1 (Configura modo de trabajo STA)

AT+CWLAP (Lista de AP en la cercanía)

AT+CWJAP=“miRED",“passRED"

AT+CIPMUX=1 (Modo Multiconexión)

AT+CIPSTART=1,"TCP","184.106.153.149",80 (Dir IP y puerto api.thingspeak.com)

AT+CIPSEND=1,62 (Tamaño incluye 0x0D y 0X0A)

> "ENTRAR LOS 63 BYTES O CARACTERES A ENVIAR"
GET /update?api_key=IXK8A63HWUQ4U3JC&field1=30.3&field2=44.1 (agregar 0x0D 0x0A en Hex para XCTU)

AT+CIPCLOSE=1 // AT+CIPCLOSE=<Id_Conexion>