Arduino - Comunicación de red

El módulo WiFi CC3000 de Texas Instruments es un pequeño paquete plateado, que finalmente brinda una funcionalidad WiFi asequible y fácil de usar para sus proyectos Arduino.

Utiliza SPI para la comunicación (¡no UART!) Para que pueda enviar datos tan rápido como desee o tan lento como desee. Tiene un sistema de interrupción adecuado con pin IRQ para que pueda tener conexiones asincrónicas. Es compatible con 802.11b / g, seguridad abierta / WEP / WPA / WPA2, TKIP y AES. Una pila TCP / IP incorporada con una interfaz de "socket BSD" admite TCP y UDP tanto en el modo de cliente como en el de servidor.

Componentes requeridos

Necesitará los siguientes componentes:

1 × Arduino Uno
1 placa de arranque Adafruit CC3000
1 relé de 5 V
1 × diodo rectificador
1 × LED
1 × resistencia de 220 ohmios
1 × Placa de pruebas y algunos cables de puente

Para este proyecto, solo necesita el IDE de Arduino habitual, la biblioteca CC3000 de Adafruit y la biblioteca MDNS CC3000. También vamos a utilizar la biblioteca aREST para enviar comandos al relé a través de WiFi.

Procedimiento

Siga el diagrama del circuito y realice las conexiones como se muestra en la imagen que se muestra a continuación.

La configuración del hardware para este proyecto es muy sencilla.

Conecte el pin IRQ de la placa CC3000 al pin número 3 de la placa Arduino.
VBAT al pin 5 y CS al pin 10.
Conecte los pines SPI a la placa Arduino: MOSI, MISO y CLK a los pines 11, 12 y 13, respectivamente.
V _in está conectado a Arduino 5V y GND a GND.

Conectemos ahora el relé.

Después de colocar el relé en la placa de prueba, puede comenzar a identificar las dos partes importantes en su relé: la parte de la bobina que controla el relé y la parte del interruptor donde conectaremos el LED.

Primero, conecte el pin número 8 de la placa Arduino a un pin de la bobina.
Conecte el otro pin a la tierra de la placa Arduino.

También debe colocar el diodo rectificador (ánodo conectado al pin de tierra) sobre los pines de la bobina para proteger su circuito cuando el relé está cambiando.

Conecte el + 5V de la placa Arduino al pin común del interruptor del relé.
Finalmente, conecte uno de los otros pines del interruptor (generalmente, el que no está conectado cuando el relé está apagado) al LED en serie con la resistencia de 220 Ohm, y conecte el otro lado del LED a la tierra de Arduino tablero.

Prueba de componentes individuales

Puede probar el relé con el siguiente boceto:

const int relay_pin = 8; // Relay pin

void setup() {
   Serial.begin(9600);
   pinMode(relay_pin,OUTPUT);
}

void loop() {
   // Activate relay
   digitalWrite(relay_pin, HIGH);
   // Wait for 1 second
   delay(1000);
   // Deactivate relay
   digitalWrite(relay_pin, LOW);
   // Wait for 1 second
   delay(1000);
}

Código a tener en cuenta

El código se explica por sí mismo. Simplemente puede cargarlo en la placa y el relé cambiará de estado cada segundo, y el LED se encenderá y apagará en consecuencia.

Agregar conectividad WiFi

Ahora controlemos el relé de forma inalámbrica utilizando el chip WiFi CC3000. El software de este proyecto se basa en el protocolo TCP. Sin embargo, para este proyecto, la placa Arduino ejecutará un pequeño servidor web, por lo que podemos "escuchar" los comandos que vienen de la computadora. Primero nos ocuparemos del boceto de Arduino, y luego veremos cómo escribir el código del lado del servidor y crear una interfaz agradable.

Primero, el boceto de Arduino. El objetivo aquí es conectarse a su red WiFi, crear un servidor web, verificar si hay conexiones TCP entrantes y luego cambiar el estado del relé en consecuencia.

Partes importantes del código

#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <Ethernet.h>
#include <aREST.h>

Debe definir dentro del código lo que es específico para su configuración, es decir, el nombre y la contraseña de Wi-Fi, y el puerto para las comunicaciones TCP (aquí hemos usado 80).

// WiFi network (change with your settings!)
   #define WLAN_SSID "yourNetwork" // cannot be longer than 32 characters!
   #define WLAN_PASS "yourPassword"
   #define WLAN_SECURITY WLAN_SEC_WPA2 // This can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, 
   // WLAN_SEC_WPA or WLAN_SEC_WPA2

// The port to listen for incoming TCP connections
   #define LISTEN_PORT 80

Luego podemos crear la instancia CC3000, el servidor y una instancia REST -

// Server instance
   Adafruit_CC3000_Server restServer(LISTEN_PORT); // DNS responder instance
   MDNSResponder mdns; // Create aREST instance
   aREST rest = aREST();

En la parte de configuración () del boceto, ahora podemos conectar el chip CC3000 a la red:

cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);

¿Cómo sabrá la computadora dónde enviar los datos? Una forma sería ejecutar el boceto una vez, luego obtener la dirección IP de la placa CC3000 y modificar el código del servidor nuevamente. Sin embargo, podemos hacerlo mejor, y ahí es donde entra en juego la biblioteca CC3000 MDNS. Asignaremos un nombre fijo a nuestra placa CC3000 con esta biblioteca, para que podamos escribir este nombre directamente en el código del servidor.

Esto se hace con el siguiente código:

if (!mdns.begin("arduino", cc3000)) {
   while(1);
}

También necesitamos escuchar las conexiones entrantes.

restServer.begin();

A continuación, codificaremos la función loop () del boceto que se ejecutará continuamente. Primero tenemos que actualizar el servidor mDNS.

mdns.update();

El servidor que se ejecuta en la placa Arduino esperará las conexiones entrantes y manejará las solicitudes.

Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);

Ahora es bastante fácil probar los proyectos a través de WiFi. Asegúrese de actualizar el boceto con su propio nombre y contraseña de WiFi, y cargue el boceto en su placa Arduino. Abra su monitor serial Arduino IDE y busque la dirección IP de su placa.

Supongamos para el resto aquí que es algo así como 192.168.1.103.

Luego, simplemente vaya a su navegador web favorito y escriba -

192.168.1.103/digital/8/1

Debería ver que su relé se enciende automáticamente.

Construcción de la interfaz de retransmisión

Ahora codificaremos la interfaz del proyecto. Aquí habrá dos partes: un archivo HTML que contiene la interfaz y un archivo Javascript del lado del cliente para manejar los clics en la interfaz. La interfaz aquí se basa en elaREST.js proyecto, que fue creado para controlar fácilmente dispositivos WiFi desde su computadora.

Veamos primero el archivo HTML, llamado interface.html. La primera parte consiste en importar todas las bibliotecas necesarias para la interfaz -

<head>
   <meta charset = utf-8 />
   <title> Relay Control </title>
   <link rel = "stylesheet" type = "text/css" 
      href = "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
   <link rel="stylesheet" type = "text/css" href = "style.css">
   <script type = "text/javascript" 
      src = "https://code.jquery.com/jquery-2.1.4.min.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/Foliotek/AjaxQ/master/ajaxq.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/marcoschwartz/aREST.js/master/aREST.js"></script>
   <script type = "text/javascript" 
      src = "script.js"></script>
</head>

Luego, definimos dos botones dentro de la interfaz, uno para encender el relé y el otro para apagarlo nuevamente.

<div class = 'container'>
   <h1>Relay Control</h1>
   <div class = 'row'>
      <div class = "col-md-1">Relay</div>
      <div class = "col-md-2">
         <button id = 'on' class = 'btn btn-block btn-success'>On</button>
      </div>
      <div class = "col-md-2">
         <button id = 'off' class = 'btn btn-block btn-danger'>On</button>
      </div>
   </div>
</div>

Ahora, también necesitamos un archivo Javascript del lado del cliente para manejar los clics en los botones. También crearemos un dispositivo que enlazaremos al nombre mDNS de nuestro dispositivo Arduino. Si cambió esto en el código Arduino, deberá modificarlo aquí también.

// Create device
var device = new Device("arduino.local");
// Button

$('#on').click(function() {
   device.digitalWrite(8, 1);
});

$('#off').click(function() {
   device.digitalWrite(8, 0);
});

El código completo de este proyecto se puede encontrar en el GitHubrepositorio. Vaya a la carpeta de la interfaz y simplemente abra el archivo HTML con su navegador favorito. Debería ver algo similar dentro de su navegador:

Intente hacer clic en un botón de la interfaz web; debería cambiar el estado del relé casi instantáneamente.

Si lograste que funcionara, ¡bravo! Acabas de construir un interruptor de luz controlado por Wi-Fi. Por supuesto, puedes controlar mucho más que luces con este proyecto. Solo asegúrese de que su relé admita la energía requerida para el dispositivo que desea controlar, y estará listo para comenzar.

↰ Previous page Next page ↱