Comenzando con Intel Galileo

IMG_20161206_202348Tomando en cuenta una pequeña comunidad que hay acá en C.R. sobre Intel Galileo GEN2, acá les presentamos un pequeño resumen introductorio.

La línea Galileo de Intel parece estar más orientada a la parte didáctica de microcontroladores que funcionan con ARDUINO mezclada con Micro-computadores que corren LINUX.

Enlace con Especificaciones

Para “iniciar” con este dispositivo no se necesita mayor cosa, solo un cable de tipo USB-a-microUSB (~$6) para programarlo mediante el ambiente ARDUINO IDE. Es el mismo tipo de cable que se usa para cargar una mayoría de teléfonos Android desde una PC.

Hay un tutorial en Inglés acá: https://software.intel.com/en-us/get-started-galileo-windows

Para sacarle mayor provecho se recomienda tener lo siguiente:
• Tarjeta Micro SD de 2GB a 32GB (crcibernetica ~$8) Para instalar una versión LINUX personalizada
• Cable de tipo “6-pin Serial to Type A USB cable (FTDI cable # TTL-232R-3V3 is recommended ($20 en Amazon)” o interfaz USB/SERIAL/FTDI tipo FOCA 2.2 ($ 11 en crcibernetica) Para acceder a la consola LINUX
• Tarjeta WiFi para laptop (Centrino N135 o Centrino 6205 ~$11-$14 en Amazon) para darle conectividad WiFi. Ambas tarjetas requieren este accesorio.

La presentación estándar de Intel Galileo GEN2 incluye la fuente de poder.

El dispositivo puede ser programado con ARDUINO IDE o mediante la plataforma LINUX que corre.

Intel Curie – Punto de Partida (Documento Cambiante)

Acá algunos enlaces útiles para desarrollar con Intel Curie:

 

 

 

Robot de dos llantas y un micro-controlador S4A-EDU

Descripción

En este experimento vamos a montar un pequeño robot de dos ruedas que controla su trayectoria mediante la diferencia de velocidad de cada rueda. Para esto utilizaremos un micro-controlador denominado S4A-EDU (Sketch 4 Arduino EDUCATION). El cual implementa la circuitería necesaria para controlar dos motores DC incluyendo la implementación de dos circuitos de “Puente H” que se utilizan para controlar la dirección en la que gira cada motor manipulando la polaridad a la que son expuestos.

Este es un experimento resumido que require un nivel de conocimiento medio en Arduino y Electrónica.


Referencias Externas

  1. Manual Introductorio del Microcontrolador (en inglés): S4AIntroduction
  2. Sketch for Arduino: http://s4a.cat

Advertencia y Condiciones de Uso

(!) Antes de seguir estas instrucciones asegúrese de entender las Condiciones de Uso de nuestro sitio.


Materiales


Pasos Resumidos

A. Montaje y Prueba Inicial

  1. Ensamble el chasis con las ruedas y los motores (siguiendo las instrucciones del fabricante)
  2. Agregue  el microcontrolador S4A-EDU al chasis
  3. Asegúrese de que el interruptor on/off del micro-controlador S4A-EDU está colocado en la posición de OFF
  4. Conecte el micro-controlador S4A-EDU al computador usando un cable de USB a Mini-USB
  5. Windows:
    1. Instale el “controlador de windows” para el puerto USB del microcontrolador CP210x (nosotros lo descargamos de este enlace)
  6. Arduino IDE:
    1. Instale y seleccione la tarjeta “Amtel atmega328p xplained mini“. La encontramos buscando “328p” en Tools > Boards > Boards Manager
    2. Configure  el puerto correspondiente. Para nuestro caso aparece  en el “Device Manager” como “Silicon Labs CP210x USB to UART Bridge en COMxx
    3. Abra el ejemplo  “Blink” (File > Examples > 01.Basics > Blink) y subirlo al microcontrolador.
    4. En este punto la luz (azul en nuestro caso) del S4A-EDU parpadea cada segundo. Nótese que el interruptor on/off del micro-controlador está todavía en la posición OFF.
    5. (!) En este punto tenemos un chasis de robot con dos ruedas, con un micro-controlador S4A-EDU montado sobre el chasis el cual podemos programar utilizando el ARDUINO IDE.

B. Trabajando en los motores

En esta etapa vamos a conectar los motores al micro-controlador S4A-EDU y vamos a utilizar un programa básico para hacer que el robot “gire sobre su propio eje”. Esto es, hacer que una de las llantas se mueva en una dirección y la otra llanta en la dirección opuesta, ambas a la misma velocidad.

  1. Conexiones:
    1. Asegúrese de que el interruptor on/off del micro-controlador S4A-EDU está colocado en la posición de OFF
    2. Conecte el positivo de cada motor (cable rojo) y el negativo (cable negro) de cada motor según se indica en la parte inferior derecha de la siguente imagen.robot_rotate
    3. En nuestro caso, vamos a alimentar el sistema mediante una batería LIPO 3.7V de 2500MAh.  (!) Nótese que el circuito funciona con 6-9V según las especificaciones. Nosotros en este experimento usamos un convertidor de 3V a 5V el cual parece funcionar perfectamente.
  2. Arduino IDE:
    1. Abra un nuevo programa en el ARDUINO IDE, y pegue en él el código de este archivo: https://github.com/janunezc/robotics/blob/master/_02_s4a_edu_rotate/_02_s4a_edu_rotate.ino
    2. Cárguelo al S4A EDU
  3. Funcionamiento del Programa:
    1. En la función “setup()” se definen los pines del controlador utilizados para manipular los motores junto con el pin 13 que se utiliza para ilumnar el LED integrado en el micro-controlador S4A-EDU; que nos va a servir de medio para ver la ejecución del programa.
    2. Una vez definidos los pines de salida se hace una llamada a la función doBlink la cual hace parpadear rápidamente el LED integrado como indicativo del que el Setup está completado.
    3. Seguidamente se configuran la velocidad y dirección de cada motor. Es en este momento que el robot comienza a girar.
    4. La función loop() permanece vacía en este caso.
    5. La función setMotor() se encarga de manipular los pines de velocidad y dirección para el motor solicitado.
    6. La función doBlink() se encarga de hacer parpadear el LED del micro-controlador un numero de veces determinado con una espera entre transiciones tambien determinado en los parámetros.
  4. (!) En este punto. Al desconectar el cable USB del micro-controlador S4A-EDU y poner el interruptor a la posición ON, el sistema parpadea 10 veces el LED indicador y comienza a girar sobre su propio eje.

Agradecimientos

Queremos expresar nuestro agradecimiento a nuestro colega Gerardo Mora y al estudiante Jean Paul Jimenez por acompañarnos en esta aventura de descubrir el funcionamiento de los diferentes componentes de este robot.

Más material para IoT: El FONA 808 de Adafruit

En esta ocasión estaremos evaluando el FONA 808 de Adafruit; un dispositivo verdaderamente completo para realizar comunicaciones en redes 3G, GSM, GPRS que además trae radio FM y Receptor GPS. Todo por menos de $55.

Dentro de las principales aplicaciones para este dispositivo tenemos la implementación de sistemas de seguimiento de vehículos por GPS con información enviada por internet (monitoreo de flotillas o sistemas para recuperación de vehículo robado) y la creación de tu propio celular.

La lista completa de especificaciones e instrucciones se puede encontrar acá: https://www.adafruit.com/product/2542

Dentro de lo que más nos llamó la atención podemos destacar:

  • GSM de cuatro bandas 850/900/1800/1900MHz para conectarse con prácticamente cuaquier proveedor de red GSM (el ICE por ejemplo)
  • Receptor GPS completamente integrado que puede ser controlado y leido a través de un único puerto serial (Chipset MT3337 con una sensibilidad de seguimiento de -165 dBm)
  • Capacidad de realizar llamadas de voz usando un manos-libres o un parlante de 32Ω  con micrófono electret
  • Capacidad de envío y recepción de mensajería SMS
  • Envío y recepción de datos GPRS (TCP/IP, HTTP, etc) (ESTA ES LA PARTE IOT!)
  • Control de motor de vibración / buzzer PWM
  • Interfaz de comandos “AT” con detección automática de bandasy comandos AT para los módulos GPRS y GPS también. (ver manual de referencia acá para SIM808 y acá para el GPS)
  • Biblioteca para ARDUINO IDE bastante estable y completa (Arduino FONA Library by Adafruit Version 1.3.2) con ejemplos de las diferentes funciones del dispositivo. Puede obtenerse directamente desde el administrador de librerías de ARDUINO IDE o desde github

Referencias

Este tutorial está basado en el tutorial de Adafruit publicado aca: https://learn.adafruit.com/adafruit-fona-808-cellular-plus-gps-breakout

Aviso de Responsabilidad Limitada

(!) Antes de seguir estas instrucciones asegúrese de entender las Condiciones de Uso de nuestro sitio.

Experimento Básico

Este experiento toma menos de una hora si ya tienes todos los materiales a mano. Consiste en instalar la biblioteca ARDUINO FONA en el ARDUINO IDE 1.6.8 y ejecutar algunas pruebas con el sketch de ejemplo llamado “FONATest”


MATERIALES: ($120)

  • 1x ARDUINO UNO ($25)
  • 1x Adafruit FONA808 ($55)
  • 1x Cable USB para programar el ARDUINO ($9)
  • 1x Batería LIPO standard de 3.7V con conector JST ($19)
  • 1x Antena Pasiva de GPS ($6)
  • 1x Antena GPRS ($4)
  • 1x Tarjeta SIM 3g/GSM (~$2)
  • 1x Computador con puertos USB disponible y sistema operativo Windows (puede ser LINUX o OSX, pero este procedimiento lo realizamos con Windows 8.1)

RESUMEN

  • PASO 1: Conecte los componentes e instale una tarjeta SIM (en nuestro caso usamos una tarjeta SIM del proveedor Kolbi del I.C.E. de Costa Rica, de un servicio MIFI que habíamos contratado de previo)
  • PASO 2: Instale la biblioteca Arduino FONA Library by Adafruit Version 1.3.2 usando la opción de menú “Manage Libraries” (Menu>Sketch>Include Library>Manage Libraries)
  • PASO 3: Modifique la biblioteca para reemplazar el APN de FONAnet al APN de su proveedor de red (kolbi3g en nuestro caso)
  • PASO 4: Abra el ejemplo “FONA Test”
    Menu>File>Exampels>Adafruit FONA Library>FONAtest
  • PASO 5: Ejecute pruebas:
    1. Encender GPS
    2. Leer Ubicación GPS
    3. Encender GPRS
    4. Leer Ubicación GPRS

PASOS Detallados:

PASO 1 – Conexiones Eléctricas

adafruit_products_2542_iso_demo_SIZED

Aparte de conectar la batería y las antenas, el FONA808 trae una hilera de pines para ser soldados.

Los pines se describen (en inglés) con mayor detalle en este enlace: https://learn.adafruit.com/adafruit-fona-808-cellular-plus-gps-breakout/pinouts

En este otro enlace también se ilustra el procedimiento para soldar los pines y para insertar la tarjeta SIM. (!) Es importante destacar que el pin VIO y el pin KEY son sumamente importantes para poder encender el FONA 808. El pin VIO determina el voltaje de referencia de las entradas y salidas. Para un ARDUINO UNO debe ser 5V, pero hay otros controladores que funcionan con 3.3V. El pin KEY se pone a tierra (GND) para que el dispositivo permanezca encendido. Se puede dejar suelto, pero habría que presionar el botón KEY del dispositivo para encenderlo.

Edición 2017-03-02: Es indispensable contar con la batería LIPO 3.3V. Sin esta batería el módulo no funciona.

También, aquí se detalla en inglés el procedimiento para conectar el dispositivo a una tarjeta ARDUINO. Estas conexiones se listan seguidamente:

  • FONA VIO ==> ARDUINO 5V      (Rojo)
  • FONA GND ==> ARDUINO GND     (Negro)
  • FONA KEY ==> ARDUINO GND     (Café)
  • FONA RX  ==> ARDUINO 2 (TX)  (Amarillo)
  • FONA TX  ==> ARDUINO 3 (RX)  (Naranja)
  • FONA RTS ==> ARDUINO 4 (D4) (Verde) (*) No confunfir el pin RTS del FONA 808 con el RST. RTS se encuentra justo entre KEY y TX

IMG_20160603_125613

PASO 2 – Instale la biblioteca “Arduino FONA Library by Adafruit Version 1.3.2”

Usando la opción de Menú “Manage Libraries” (Menu>Sketch>Include Library>Manage Libraries) Busque e instale la biblioteca “Arduino FONA Library by Adafruit Version 1.3.2”

Capture     Capture3

PASO 3 – Modifique la biblioteca para usar el APN adecuado

Aparentemente por error, la librería trae “hard-coded” el nombre del Access Point Name (APN) para la red GPRS apuntando a “FONAnet” esto hace que las pruebas para la red GPRS no funcionen. Para solventar este problema, consiga el APN de su proveedor de red (en mi caso kolbi3g es el que usamos para la red celular del ICE)

  • Abra el archivo de la librería Adafruit_FONA.cpp ubicado normalmente en la siguiente carpeta de su sistema Windows:
    C:\Users\usuario\Documents\Arduino\libraries\Adafruit_FONA_Library/
  • (!) Para habilitar el GPRS: modifique la línea apn = F("FONAnet"); (línea 28) con la línea  apn = F("kolbi3g");

PASO 4 – Use el programa (sketch) de ejemplo FONA TEST

Abra el programa de ejemplo FONAtest desde el menú (Menu>File>Exampels>Adafruit FONA Library>FONAtest) y súbalo a su ARDUINO UNO.

Una vez que haya terminado de subir el programa, abra el monitor de puerto serial [SHIFT] + [CTRL] + [M]

Asegúrese de que la configuración de velocidad e interpretación del Monitor Serial sean las adecuadas.

adafruit_products_checkbaud

PASO 5 – Pruebas Específicas

El monitor de puerto serial mostrará un Menú y recibirá comandos desde la caja de texto que se encuentra en la parte superior de la pantalla.

Digite “?” y [ENTER] para mostrar el menú de opciones. El menú disponible varia para las diferentes versiones del dispositivo. En nuestro caso tenemos el FONA 808 V2.

Digite “O” y [ENTER] para encender el GPS

Digite “L” y [ENTER] para leer la posición del GPS. Nótese que el formato consiste en una serie de valores separados por comas. El 2do valor es un 0 (cero) cuando el dispositivo aun no se ha conectado a suficientes satélites para identificar su ubicación global, y 1 (uno) cuando si está conectado.

Digite “o” y [ENTER] para apagar el GPS.

Digite “G” y [ENTER] para activar el sistema GPRS. Esto permite la comunicación por internet y el sistema de posicionamiento basado en antenas de la red celular.

Digite “l” y [ENTER] para consultar la ubicación de acuerdo con el sistema GPRS. Es un sistema alternativo al GPS, muchas veces de menor precisión pero de más fácil “adquisición”.

El Nuevo ARDUINO MKR1000 es una belleza

Hoy probamos por un rato el Arduino MKR1000 (GENUINO MKR1000 que es lo mismo)

Se trata de uno de los productos más recientes de la familia ARDUINO, un microcontrolador que incorpora conectividad WiFi y encripción por hardware, lo cual le permite conectarse al Internet usando protocolo HTTPS; que – en mi opinión – lo ubica por encima del afamado Sparkfun Thing ESP8266.

Pueden ver las especificaciones de este dispositivo acá: https://www.arduino.cc/en/Main/ArduinoMKR1000

Dentro de las funciones más destacadas podemos mencionar:

  • Microcontrolador de bajo consumo eléctrico de 32 bits.
  • Puerto de alimentación USB de 5V
  • Conector para batería LIPO de 3.7V, 700mAh
  • Voltaje de operación de 3.3V (! Importante… por que el voltaje aplicado a los puertos de GPIO no debe superar los 3.3V)
  • 8 (ocho) puertos de I/O Digitales de propósito general, que incluyen 4 (cuatro) pines PWM
  • 1 Puerto serial UART
  • 1 Puerto SPI
  • 1 Puerto I2C
  • 7 Entradas analógicas de 8/10/12 bits
  • 1 Salida Analógica (DAC de 10 bits)
  • 8 Puertos con capacidad de interrupción externa (0,1,4,5,6,7,8,A1,A2)
  • Capacidad de entregar 7mA de corriente en cada I/O Pin
  • Memoria no-volatil (FLASH) de 256KB
  • Memoria Volatil (SRAM) de 32KB
  • RTC de 32.768 KHz
  • 48MHz de Procesamiento
  • Puerto USB como cliente y embedded host
  • Comunicación WiFi
  • Chip de Encripción que permite la comunicación por protocolo SSL
  • Precio al momento de escribir este artículo: ~$35 (aca)
  • Utiliza la libreria Wifi101 disponible en la ultima version del ARDUINO IDE.

Lo primero que probamos – SSL

Por supuesto, la capacidad de conectarse a un servidor via HTTPS/SSL. Para esto utilizamos el tutorial titulado “Scheduled WiFi SSL Web Client“; solo que le realizamos algunas modificaciones para entender mejor el código… pueden encontrarse aca: enlace o ver listado 1 abajo.

Lo segundo que probamos – Access Point

Como ya dijimos, es compatible con la librería WiFi101; así que decidimos probar el ejemplo llamado “AP_SimpleWebSever” el cual implementa un Access Point, y un servidor web que escucha en la dirección IP 192.168.1.1 y sirve un par de enlaces que automáticamente encienden y apagan un LED. Ver Listado 2 abajo.

2016-05-24_2035

 

Listado 1 – SSL + MKR1000 + PVCLOUD TEST

/*
  Scheduled WiFi SSL Web Client for MKR1000

  This sketch connects to the Arduino website every minute and downloads the ASCII logo to display it on the serial monitor

  created 19 Jan 2016
  by Arturo Guadalupi <a.guadalupi@arduino.cc>

  http://arduino.cc/en/Tutorial/

  This code is in the public domain.

  Modified by Jose Nunez <jose.nunez@intel.com> 
  
*/

#include 
#include 
#include 

char ssid[] = "opodiym";      //  your network SSID (name)
char pass[] = "luaus7151";       // your network password

int keyIndex = 0;                  // your network key Index number (needed only for WEP)

int status = WL_IDLE_STATUS;

// Initialize the Wifi client library
WiFiSSLClient client;
 
// server address:
char server[] = "costaricamakers.com";

bool sendRequest = true; // used to understand if the http request must be sent

/* Create an rtc object */
RTCZero rtc;

/* Change these values to set the current initial time */
const byte seconds = 50;
const byte minutes = 00;
const byte hours = 17;

/* Change these values to set the current initial date */
const byte day = 24;
const byte month = 05;
const byte year = 16;

void setup() {
  delay(3000);
  Serial.begin(115200);
  serialOut("Begin...");

  serialOut("Connecting to Access Point...");
  connectToAP();    // connect the board to the access point
  
  serialOut("Printing WIFI Status...");
  printWifiStatus();

  serialOut("Making initial HTTP Request...");
  httpRequest();

  serialOut("Calling listenToClient()...");
  listenToClient();

  serialOut("Setting RTC Up...");
  rtc.begin();
  rtc.setTime(hours, minutes, seconds);
  rtc.setDate(day, month, year);

  rtc.setAlarmTime(0, 0, 0);    //in this way the request is sent every minute at 0 seconds
  rtc.enableAlarm(rtc.MATCH_SS);

  rtc.attachInterrupt(alarmMatch);

  serialOut("SETUP COMPLETE");
}
void loop() {
 
  if (sendRequest) {
    serialOut("sendRequest was TRUE");
    sendRequest = false;

    serialOut("Calling httpRequest()...");
    httpRequest();

    serialOut("Calling listenToClient()...");
    listenToClient();
  }
}

void printWifiStatus() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}

void alarmMatch() {
  sendRequest = true;
}

void connectToAP() {
  // check for the presence of the shield:
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("WiFi shield not present");
    // don't continue:
    while (true);
  }

  // attempt to connect to Wifi network:
  while ( status != WL_CONNECTED) {
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(ssid);
    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:
    status = WiFi.begin(ssid, pass);

    // wait 1 second for connection:
    delay(1000);
  }
}

// this method makes a HTTP connection to the server:
void httpRequest() {
  sendRequest = false;

  // Print request time
  Serial.println();
  Serial.print("Request sent @ ");
  print2digits(rtc.getHours());
  Serial.print(":");
  print2digits(rtc.getMinutes());
  Serial.print(":");
  print2digits(rtc.getSeconds());
  Serial.println();
  Serial.println();

  if (client.connect(server, 443)) {
    // Make a HTTP request:
    client.println("GET /pvcloud_test/mkr1000test.json HTTP/1.1");
    client.println("Host: costaricamakers.com");
    client.println("User-Agent: MKR1000/1.1");
    client.println("Connection: close");
    client.println();
  }
  else {
    Serial.println("connection failed");
  }
}

void listenToClient()
{
  unsigned long startTime = millis();
  bool received = false;

  while ((millis() - startTime < 5000) && !received) { //try to listen for 5 seconds
    while (client.available()) {
      received = true;
      char c = client.read();
      Serial.write(c);
    }
  }
  client.stop();
  Serial.println();
  serialOut("listenToClient() FINISHED");
}

void print2digits(int number) {
  if (number < 10) {
    Serial.print("0");
  }
  Serial.print(number);
}

void serialOut(String message){
  Serial.println("-------------------------------------------------------------------------------");
  Serial.print(millis());
  Serial.print(": ");
  Serial.println(message);
}

Listado 2 – AP_SimpleWebServer

/*
  WiFi Web Server LED Blink

  A simple web server that lets you blink an LED via the web.
  This sketch will create a new access point (with no password).
  It will then launch a new server and print out the IP address
  to the Serial monitor. From there, you can open that address in a web browser
  to turn on and off the LED on pin 13.

  If the IP address of your shield is yourAddress:
    http://yourAddress/H turns the LED on
    http://yourAddress/L turns it off

  created 25 Nov 2012
  by Tom Igoe
  adapted to WiFi AP by Adafruit
 */

#include <SPI.h>
#include <WiFi101.h>

int led =  LED_BUILTIN;

char ssid[] = "wifi101-network"; // created AP name
char pass[] = "luaus7151";      // AP password (needed only for WEP, must be exactly 10 or 26 characters in length)
int keyIndex = 0;                // your network key Index number (needed only for WEP)

int status = WL_IDLE_STATUS;
WiFiServer server(80);

void setup() {
  //Initialize serial and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Serial.println("Access Point Web Server");

  pinMode(led, OUTPUT);      // set the LED pin mode

  // check for the presence of the shield:
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("WiFi shield not present");
    // don't continue
    while (true);
  }

  // print the network name (SSID);
  Serial.print("Creating access point named: ");
  Serial.println(ssid);

  // Create open network. Change this line if you want to create an WEP network:
  if (WiFi.beginAP(ssid) != WL_CONNECTED) {
    Serial.println("Creating access point failed");
    // don't continue
    while (true);
  }

  // wait 10 seconds for connection:
  delay(10000);

  // start the web server on port 80
  server.begin();

  // you're connected now, so print out the status
  printWifiStatus();
}


void loop() {
  WiFiClient client = server.available();   // listen for incoming clients

  if (client) {                             // if you get a client,
    Serial.println("new client");           // print a message out the serial port
    String currentLine = "";                // make a String to hold incoming data from the client
    while (client.connected()) {            // loop while the client's connected
      if (client.available()) {             // if there's bytes to read from the client,
        char c = client.read();             // read a byte, then
        Serial.write(c);                    // print it out the serial monitor
        if (c == '\n') {                    // if the byte is a newline character

          // if the current line is blank, you got two newline characters in a row.
          // that's the end of the client HTTP request, so send a response:
          if (currentLine.length() == 0) {
            // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
            // and a content-type so the client knows what's coming, then a blank line:
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println();

            // the content of the HTTP response follows the header:
            client.print("Click here turn the LED on
");
            client.print("Click here turn the LED off
");

            // The HTTP response ends with another blank line:
            client.println();
            // break out of the while loop:
            break;
          }
          else {      // if you got a newline, then clear currentLine:
            currentLine = "";
          }
        }
        else if (c != '\r') {    // if you got anything else but a carriage return character,
          currentLine += c;      // add it to the end of the currentLine
        }

        // Check to see if the client request was "GET /H" or "GET /L":
        if (currentLine.endsWith("GET /H")) {
          digitalWrite(led, HIGH);               // GET /H turns the LED on
        }
        if (currentLine.endsWith("GET /L")) {
          digitalWrite(led, LOW);                // GET /L turns the LED off
        }
      }
    }
    // close the connection:
    client.stop();
    Serial.println("client disconnected");
  }
}

void printWifiStatus() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
  // print where to go in a browser:
  Serial.print("To see this page in action, open a browser to http://");
  Serial.println(ip);
}