En publicaciones anteriores hemos visto diferentes mecanismos de control para nuestro robot, tanto manuales (Construyendo Nuestro Propio Robot Desde Cero – Parte 3) como autónomos (Arduino Robot Seguidor de Líneas y Laberintos). Ahora veremos una alternativa más, también inalámbrica, al igual que en la publicación anterior (Arduino Robot Controlado por Bluetooth y Android App) y que en estos últimos años ha crecido de manera exponencial en el mercado. El lector perspicaz ya advirtió que se trata de la tecnología Wi-Fi (Wireless Fidelity), omnipresente en el mercado y en nuestros hogares.
En cuanto empieces a buscar algo de Wi-Fi económico, te encontrarás con el módulo Wi-Fi ESP8266, fabricado por ESPRESSIF Systems, el cual es muy parecido a los módulos Bluetooth de la publicación anterior, y que al igual que ellos incluye toda la electrónica necesaria para la comunicación RF en la banda Wi-Fi, así como la pila TCP/IP y se comunica con nosotros a través de un puerto serie.
De hecho, exactamente al igual que los módulos Bluetooth HC-06 y HC-05, se gobierna mediante comandos AT, algo que ya no tiene secretos para los seguidores de este blog, y todo por un precio similar al de los módulos Bluetooth.
Lo primero, es decir que es un módulo muy sencillo y diseñado desde el principio con la «Internet of Things» en mente (IoT), y por eso incluye todo lo necesario para conectarse a un punto de acceso Wi-Fi o actuar por sí mismo como punto de acceso Wi-Fi mediante comandos AT, vía un puerto serie, que puede ser configurado a diferentes velocidades.
Este circuito integrado es una pequeña maravilla tecnológica. Está diseñado y pensado para ser la solución ideal para todo el que necesite un «Todo en uno Wi-Fi» para proyectos de hobby, IoT o producto comercial sin complicaciones. Y lo más importante, lo consigue.
- Voltaje de alimentación: 3.3V
- Procesador interno de 32 bits a 80 MHz (se puede incrementar hasta 160MHz).
- 80KB de DRAM.
- 35KB de IRAM, memoria rápida para el procesador.
- 512KB (hasta 1MB, dependiendo de la versión del módulo) de memoria flash para nuestros programas.
- Pila TCP/IP Wi-Fi a 2.4 GHz (b/g/n).
- 30 metros de alcance teórico.
Nota del Autor: de hecho, el módulo ESP8266 incluye un pequeño procesador interno que podríamos programar para funcionar de modo autónomo y dispone de un par de puertos GPIO (General Purpose Input Output) para su uso como activadores. Es posible programarlo desde el IDE Arduino, y más interesante aún, con MicroPython.
Lista de Componentes
1 Plataforma Turtle2WD con placa Arduino UNO R3 y Shield de Control de Motores ensamblados anteriormente.
1 Adaptador Sparkfun FTDI USB – UART TTL 3.3V
1 Módulo Wi-Fi ESP8266 (ESP-01)
1 Convertidor Bidireccional de Niveles Lógicos Sparkfun.
1 Capacitor Electrolítico 1000uF 6.3V
2 Baterías AA 1.5V de Alto Rendimiento
1 Portapilas para 2 Baterías AA
Antes de instalar el módulo en nuestro robot, modificaremos algunos parámetros de su configuración mediante comandos AT. Para llevar a cabo esta tarea sólo necesitamos descargar el documento que contiene el set de instrucciones AT ESP8266 y un emulador de terminal RS232.
Set de Instrucciones AT ESP8266
Termite 3.3
Tamaño: 294KB
SHA1 Hash: 5A7DEBD9E1F245EB87FAEF397187752D5CFF1841
Descarga Mirror
A continuación conectaremos nuestro módulo al Adaptador FTDI USB – UART TTL 3.3V como se muestra en la siguiente imagen:
Ahora, el emulador de terminal (en nuestro caso, Termite) debe estar configurado de la siguiente manera, que son los parámetros por defecto de nuestro módulo Wi-Fi.
Habiendo logrado una conexión exitosa en el paso anterior, ahora debemos enviar los comandos AT necesarios para configurar nuestro módulo. En la siguiente imagen se observa la secuencia de comandos enviados:
AT AT+CWSAP_DEF="TURTLE2WD","",1,0,4 AT+UART_DEF=19200,8,1,0,0
Nuestros comandos enviados se encuentran en color azul, en color verde se encuentran las respuestas de nuestro módulo y el eco local de la consola. Con la ejecución exitosa de estos comandos modificamos el SSID de nuestro módulo por «TURTLE2WD» para identificarlo fácilmente y redujimos la velocidad del puerto serie a 19200bps lo cual nos permite utilizar cables de mayor longitud para el montaje en caso de ser necesario.
Habiendo finalizado exitosamente los pasos anteriores, compilaremos y cargaremos en nuestro Arduino Uno R3 el sketch correspondiente, cuyo código fuente se encuentra a continuación:
/*
Caracteristicas:
- Control por Wi-Fi utilizando el modulo ESP8266
- Interfaz web con jquey para envio de peticiones GET
- Id de botones para envio de datos
W: Adelante
S: Atras
A: Izquierda
D: Derecha
L: Inicio/Parada Modo Vehiculo
Q: Incrementar Velocidad
T: Disminuir Velocidad
X: Encendido/Apagado Luz Frontal
- Detencion automatica en caso de detectar bordes.
*/
#define PWM_RIGHT 3 // (Control Velocidad Motor Derecho) Timer2 8 bits D3
#define PWM_LEFT 11 // (Control Velocidad Motor Izquierdo) Timer2 8 bits D11
#define DIR_A 12 // (Control de Direccion de Motores) D12
#define DIR_B 13 // (Control de Direccion de Motores) D13
#define MAX_SPEED 200 // Velocidad Maxima
#define MIN_SPEED 100 // Velocidad Minima
// -----
// Iluminacion
#define LED_LIGHT 7
// -----
// Sensores Reflectivos Detectores de Bordes
#define BORDER_L A2 // Sensor Izquierdo Externo
#define BORDER_R A5 // Sensor Derecho Externo
// Serial commands
#define DIR_FORWARD 'W'
#define DIR_BACKWARD 'S'
#define DIR_LEFT 'A'
#define DIR_RIGHT 'D'
#define START_STOP_V 'L'
#define INC_SPEED 'Q'
#define DEC_SPEED 'T'
#define FRONT_LIGHT 'X'
// -----
#define DEBUG false
boolean stopped;
byte speed, connectionid;
char data;
void forward() {
digitalWrite(DIR_A, LOW);
digitalWrite(DIR_B, LOW);
}
void backward() {
digitalWrite(DIR_A, HIGH);
digitalWrite(DIR_B, HIGH);
}
void rotateleft() {
digitalWrite(DIR_A, LOW);
digitalWrite(DIR_B, HIGH);
}
void rotateright() {
digitalWrite(DIR_A, HIGH);
digitalWrite(DIR_B, LOW);
}
void stop() {
analogWrite(PWM_LEFT, 0);
analogWrite(PWM_RIGHT, 0);
}
void setspeed(boolean sp) {
if (sp) {
if (speed < MAX_SPEED) {
speed += 50;
analogWrite(PWM_LEFT, speed);
analogWrite(PWM_RIGHT, speed);
}
}
else
{
if (speed > MIN_SPEED) {
speed -= 50;
analogWrite(PWM_LEFT, speed);
analogWrite(PWM_RIGHT, speed);
}
}
}
void setlight() {
digitalWrite(LED_LIGHT, !(digitalRead(LED_LIGHT)));
}
boolean isborder() {
if ((digitalRead(BORDER_L) == HIGH) || (digitalRead(BORDER_R) == HIGH))
return true;
else
return false;
}
String sendData(String command, const word timeout, boolean debug) {
String response = "";
Serial.print(command); // send the read character to the esp8266
unsigned long time = millis();
while ((time + timeout) > millis()) {
while(Serial.available()) {
// The esp has data so display its output to the serial window
char c = Serial.read(); // read the next character.
response += c;
}
}
if (debug)
Serial.print(response);
return response;
}
void setup() {
pinMode(PWM_LEFT, OUTPUT);
pinMode(PWM_RIGHT, OUTPUT);
pinMode(DIR_A, OUTPUT);
pinMode(DIR_B, OUTPUT);
pinMode(LED_LIGHT, OUTPUT);
pinMode(BORDER_L, INPUT);
pinMode(BORDER_R, INPUT);
digitalWrite(LED_LIGHT, LOW);
stopped = true;
speed = MIN_SPEED;
Serial.begin(19200);
sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); // configure for multiple connections
sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); // turn on server on port 80
}
void loop() {
if (Serial.available()) {
if (Serial.find("+IPD,")) {
delay(100);
connectionid = (Serial.read() - 48);
Serial.find("cmd=");
data = Serial.read();
if (data == START_STOP_V) {
if (stopped) {
forward();
analogWrite(PWM_LEFT, speed);
analogWrite(PWM_RIGHT, speed);
stopped = false;
}
else
{
stop();
stopped = true;
}
}
switch (data) {
case DIR_FORWARD:
if (!stopped)
forward();
break;
case DIR_BACKWARD:
if (!stopped)
backward();
break;
case DIR_LEFT:
if (!stopped)
rotateleft();
break;
case DIR_RIGHT:
if (!stopped)
rotateright();
break;
case INC_SPEED:
if (!stopped)
setspeed(true);
break;
case DEC_SPEED:
if (!stopped)
setspeed(false);
break;
case FRONT_LIGHT:
setlight();
break;
default:
break;
}
String closecommand = "AT+CIPCLOSE=" + String(connectionid) + "\r\n";
sendData(closecommand, 100, DEBUG);
}
}
if (isborder())
stop();
}
En este punto nos encontramos en la etapa final. A continuación conectaremos nuestro módulo Wi-Fi a la placa Arduino UNO R3, como se observa en la siguiente imagen:
Por último necesitamos la interfaz web desde la cual controlaremos nuestro robot. Consta de un documento HTML y jQuery, una biblioteca multiplataforma de JavaScript, que permite simplificar la manera de interactuar con los documentos HTML, manipular el árbol DOM, manejar eventos, desarrollar animaciones y agregar interacción con la técnica AJAX a páginas web. jQuery es la biblioteca de JavaScript más utilizada.
Interfaz Web
Tamaño: 27.5KB
SHA1 Hash: 0C9AE81B92C8243C362C2DFA94C79065D8D3447E
Descarga
Hardr!ve - Quod natura non dat, Salmantica non praestat 