Tag Archives: WiFi

ESP8266 – Serial WiFi Logger

14 Abr 18
Jose Nunez
, , ,
No Comments

En este proyecto corto estudiaremos el uso del módulo genérico ESP8266 como mecanismo inalámbrico para el registro de datos por WiFi en un servidor. A su vez estaremos estudiando el uso del puerto serial del ESP8266 a fin de que otro controlador pueda enviarle datos al ESP y este enviarlos de forma inalámbrica al servidor.

Este proyecto utilizará el servidor “ZUMMOBOT” que describimos en el artículo sobre Captura Masiva de Datos

El itinerario de este proyecto es el siguiente:

#1 – Conexiones y BLINK Serial
En este apartado vamos a conectar el ESP8266 a la laptop para programarlo e instalar un programa muy sencillo que solamente nos enviará datos de vuelta “ON” y “OFF” por el puerto serial a través del monitor serial de IDE ARDUINO. Esto nos permitirá entender si estamos conectándonos correctamente con el ESP8266 y si está funcionando adecuadamente.

#2 – Lector de datos (líneas) por puerto serial (tx/rx)
En esta sección estaremos programando un sketch capaz de recibir lineas de datos por el puerto serial las cuales serán reportadas de vuelta por el Monitor Serial del IDE Arduino.

#3 – Lector de comandos y datos por puerto serial (tx/rx)
En este punto usaremos un sketch que puede determinar si los datos recibidos por puerto serial corresponden a un comando que deba ejecutar el ESP8266 o a datos que deban ser transmitidos.

#4 – Envío de datos via WiFi (conexion a enrutador, y comunicación con servidor en red de área local (LAN))
Finalmente estudiaremos el sketch completo que haga las siguientes funciones:

  • Recibe datos por puerto serial.
  • Discrimina si se trata de comandos o datos a transmitir.
  • Cuando se trata de comandos, los ejecuta. Dentro de los comandos podemos mencionar SET_AP:ssid,pwd y SET_BaseURL:http://host:port/resource/
  • Cuando se trata de datos, los envía al servidor por via WiFi. En esta primera entrega solamente vamos elaborar un poco sobre la lógica; mientras que en la siguiente entrega detallaremos la comunicación WiFi.

#1 – Conexiones y Blink Serial

Se utiliza un adaptador USB Serial para PC. Las conexiones con el ESP8266 se resumen de esta manera:

ESP8266  <–> Adaptador USB/Serial para PC

VCC   <-----------  VCC (3.3V)
RST   <----
CH_PD <---R3.3K---  VCC (3.3V) (*)
TX    ------------> RX
---
RX    <-----------  TX
GPIO0 ----SW----->  GND (**)
GPIO1 -----
GND   ----------->  GND

(*) CH_PD está conectado a VCC(3.3V) por medio de un resistore de 3.3KOhm (Pull up). Existe literatura que indica una conexión directa.
(**) GPIO0 se conecta a tierra para poder programar el módulo usando el IDE de ARDUINO. En nuestro caso usamos un switch para cambiar esta configuración facilmente. Cuando GPIO0 está conectado a tierra, al encender el ESP8266 este NO EJECUTA el sketch sino que entra en modo de programación.

Una vez realizada la conexión, podemos utilizar el siguiente programa para comprobar que podemos programar el módulo y ejecutar un sketch.

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO 
  it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
  the correct LED pin independent of which board is used.
  If you want to know what pin the on-board LED is connected to on your Arduino model, check
  the Technical Specs of your board  at https://www.arduino.cc/en/Main/Products
  
  This example code is in the public domain.

  modified 13 April 2018 by Jose Nunez
  
  modified 8 May 2014
  by Scott Fitzgerald
  
  modified 2 Sep 2016
  by Arturo Guadalupi
  
  modified 8 Sep 2016
  by Colby Newman
*/


// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.println("Setup Complete");
}

// the loop function runs over and over again forever
void loop() {
  Serial.println("ON");
  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);                       // wait for a second
  Serial.println("OFF");
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);                       // wait for a second
}

 


#2 – Lector de datos (líneas) por puerto serial (tx/rx)

El siguiente programa leerá una linea de datos a la vez y la mostrará en el monitor serial del IDE de ARDUINO. Nótese que el programa está hecho para buscar los caracteres \r\n (retorno de carro, nueva línea) que es la forma en que se finalizan las líneas enviadas por el comando Serial.println() de ARDUINO.

#define DEBUG_MODE true

void setup() {
  Serial.begin(115200);
  delay(1000);

  Serial.println("SETUP COMPLETE!");
}

void loop() {
  String serialData = readSerial();
  if (isNotEmpty(serialData)) {
    logMessageln("Data Found: |" + serialData + "|");
  }
}

boolean isNotEmpty(String data) {
  return data != "";
}
String readSerial() {
  String serialData = "";
  if (Serial.available()) {
    //THIS IS INTENDED TO READ LINES WRITTEN BY ANOTHER ARDUINO USING Serial.println() function
    //WHICH WILL END COMMUNICAITON WITH \r\n 
    //https://www.arduino.cc/en/Serial/Println
    
    serialData = Serial.readStringUntil('\r\n');
  }

  return serialData;
}

void logMessageln(String message) {
  if (DEBUG_MODE) {
    String timestamp = String(millis());
    Serial.println(timestamp + "-" + message);
  }
}

 


#3 – Lector de comandos y datos por puerto serial (tx/rx)

Este sketch es muy similar al anterior pero además de leer el puerto serial, nos permite diferenciar entre lineas de comando (que comienzan con CMD:) y lineas de datos (que no comienzan con CMD:)

/**
 * 
 *  THIS SKETCH WILL READ LINES FROM SERIAL PORT. THEN DETERMINE IF THEY ARE A COMMAND (BEGINS WITH CMD) 
 *  OR IF THEY ARE JUST TEXT (DONT BEGIN WITH CMD)
 *  
 *  THIS IS INTENDED TO READ LINES WRITTEN BY ANOTHER ARDUINO USING Serial.println() function
 *  WHICH WILL END COMMUNICAITON WITH \r\n 
 *  https://www.arduino.cc/en/Serial/Println
 *  
**/
 
#define DEBUG_MODE true // SET TO false to avoid verbose messages

/*
 * THE SETUP
 */
void setup() {
  Serial.begin(115200);
  delay(1000);

  Serial.println("SETUP COMPLETE!");
}

/**
 * THE LOOP
 */
void loop() {
  String serialData = readSerial();
  if (isNotEmpty(serialData)) {
    if(isCommand(serialData)){
      String commandData = extractCommand(serialData);
      logMessageln("Command Found: |" + commandData + "|");
    } else{
      logMessageln("Data Found: |" + serialData + "|");
    }
  }
}

boolean isNotEmpty(String data) {
  return data != "";
}

boolean isCommand (String data) {
  return data.startsWith("CMD:");
}

String extractCommand (String data){
  if (isCommand(data)){
    return data.substring(4);
  } else {
    return "";
  }
}
String readSerial() {
  String serialData = "";
  if (Serial.available()){
    serialData = Serial.readStringUntil('\r\n');
  }

  return serialData;
}

void logMessageln(String message) {
  if (DEBUG_MODE) {
    String timestamp = String(millis());
    Serial.println(timestamp + "-" + message);
  }
}

 


#4 – Envío de datos via WiFi (conexion a enrutador, y comunicación con servidor en red de área local (LAN))

Ya para finalizar, les compartimos el script que hace posible conectarse a cualquier red y cualquier servidor con capacidad de respuesta HTTP de su red de area local (LAN).

Para una mayor comprensión del código vamos a mostrar dos listados. Este primer listado solo muestra la lógica de ejecución sin entrar en detalles de la comunicación WiFi.

/**
 * 
 *  THIS SKETCH WILL READ LINES FROM SERIAL PORT. THEN DETERMINE IF THEY ARE A COMMAND (SET_AP: or SET_BaseURL:) 
 *  OR IF THEY ARE JUST TEXT (DONT BEGIN WITH EITHER SET_AP: nor SET_BaseURL:)
 *  
 *  THIS IS INTENDED TO READ LINES WRITTEN BY ANOTHER ARDUINO USING Serial.println() function
 *  WHICH WILL END COMMUNICAITON WITH \r\n 
 *  https://www.arduino.cc/en/Serial/Println
 *  
**/
 
#define DEBUG_MODE true // SET TO false to avoid verbose messages
String APName = "";
String APPWD  = "";
String BaseURL = "";
/*
 * THE SETUP
 */
void setup() {
  Serial.begin(115200);
  delay(1000);

  Serial.println("SETUP COMPLETE!");
}

/**
 * THE LOOP
 */
void loop() {
  String serialData = readSerial();
  if (isNotEmpty(serialData)) {
    if(isCommand(serialData)){
      executeCommand(serialData);
    } else{
      sendDataToWiFi(serialData);
    }
  }
}

boolean isNotEmpty(String data) {
  return data != "";
}

boolean isCommand (String data) {
  return data.startsWith("SET_AP:")
  ||     data.startsWith("SET_BaseURL:");
}

String executeCommand (String data){
  if(data.startsWith("SET_AP:")){
    logMessageln("SET_AP command found!");
    int commaLocation = data.indexOf(",");
    APName = data.substring(7,commaLocation);
    APPWD  = data.substring(commaLocation+1);
    logMessageln("APName set to: " + APName);
    logMessageln("APPWD  set to: " + APPWD);
  } else if (data.startsWith("SET_BaseURL:")) {
    logMessageln("SET_BaseURL command found!");
    BaseURL = data.substring(12);
    logMessageln("BaseURL set to: " + BaseURL);
  }
}

String readSerial() {
  String serialData = "";
  if (Serial.available()){
    serialData = Serial.readStringUntil('\r\n');
  }

  return serialData;
}

void sendDataToWiFi(String data){
  if(APName=="") {
    logMessageln("AP Not Defined! use SET_AP:ssid,pwd command to set it up");
    return;
  }

  if(BaseURL ==""){
    logMessageln("BaseURL Not Defined! use SET_BaseURL:http://host:port/route/resource command to set it up");
    return;    
  }
  
  logMessageln("Data to be sent via WiFi...");
  logMessageln("Network: " + APName + "|" + APPWD);
  String urlToCall = BaseURL + "?" + data;
  logMessageln("Request: GET " + urlToCall); 
}

void logMessageln(String message) {
  if (DEBUG_MODE) {
    String timestamp = String(millis());
    Serial.println(timestamp + "-" + message);
  }
}

Esto muestra un poco los pasos lógicos para nuestro receptor de datos via puerto serial. El siguiente listado muestra todos los detalles de la comunicación WiFi.

Utilizamos las bibliotecas ESP8266WiFi y ESP8266HTTPClient para facilitar la generación de solicitudes HTTP de tipo GET.

Durante el SETUP del sketch nos conectamos a una red WIFI determinada por las variables globales APName y APPWD.

Luego durante el proceso de LOOP, recibimos datos en la forma de “querystrings”; es decir, llave_1=valor_1&llave_2=valor_2&llave_n-valor_n

Usando estos datos se construye un URL que será enviado al servidor usando la variable global BaseURL y el método HTTP GET.

(!) La lógica referente a cambiar de red WiFi usando el comando SET_AP:ssid,pwd no funciona todavía; pues nos falta explorar un poco la forma adecuada de cambiar de red WiFi.

/**

THIS SKETCH WILL READ LINES FROM SERIAL PORT. THEN DETERMINE IF THEY ARE A COMMAND (SET_AP: or SET_BaseURL:)
OR IF THEY ARE JUST TEXT (DONT BEGIN WITH EITHER SET_AP: nor SET_BaseURL:)

THIS IS INTENDED TO READ LINES WRITTEN BY ANOTHER ARDUINO USING Serial.println() function
WHICH WILL END COMMUNICAITON WITH \r\n
https://www.arduino.cc/en/Serial/Println

**/

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

#define DEBUG_MODE true // SET TO false to avoid verbose messages

String VERSION = "20180415-1644";
String APName = "wifi ssid goes here";
String APPWD = "wifi password goes here";
String BaseURL = "http://192.168.0.3/zummobotdb/set.php";

/**********************************************************/
void setup() {
   Serial.begin(115200);
   delay(1000);
   logMessageln("HI! WELCOME TO serial_wifi_logger.ino " + VERSION);
   for (int i = 5; i > 0; i--) {
      logMessageln("Countdown: " + String(i));
      delay(1000);
   }
   logMessageln("SETUP!");
   logMessageln("WELCOME TO serial_wifi_logger.ino " + VERSION);
   logMessageln("Default APName|PWD:" + APName + "|" + APPWD );

   connectToWiFiAP(APName, APPWD);
   logMessageln("SETUP COMPLETE!");
}

/**********************************************************/
String connectToWiFiAP(String ssid, String pwd) {
   logMessageln("ConnectToWiFiAP(" + ssid + "," + pwd + ")");
   char _ssid[30];
   char _pwd[30];

   logMessageln("Converting Strings to Char Arrays...");
   ssid.toCharArray(_ssid, sizeof(_ssid));
   pwd.toCharArray(_pwd, sizeof(_pwd));

   logMessageln("WIFIMODE: STA");
   WiFi.mode(WIFI_OFF);
   WiFi.mode(WIFI_STA);

   logMessageln("WiFi.begin('" + String(_ssid) + "','" + String(_pwd) + "')");
   WiFi.begin(_ssid, _pwd);

   logMessageln("Conecting to WiFi AP...");
   while (WiFi.status() != WL_CONNECTED) {
      delay(500);
      Serial.print(".");
   }

   logMessageln("Connected!");
}

/**********************************************************/
void loop() {
   String serialData = readSerial();
   if (isNotEmpty(serialData)) {
      if (isCommand(serialData)) {
         executeCommand(serialData);
      } else {
         sendDataToWiFi(serialData);
      }
   }
}

boolean isNotEmpty(String data) {
   return data != "";
}

boolean isCommand (String data) {
   return data.startsWith("SET_AP:")
   || data.startsWith("SET_BaseURL:");
}

String executeCommand (String data) {
   if (data.startsWith("SET_AP:")) {
      logMessageln("SET_AP command found!");
      int commaLocation = data.indexOf(",");
      APName = data.substring(7, commaLocation);
      APPWD = data.substring(commaLocation + 1);
      logMessageln("APName set to: " + APName);
      logMessageln("APPWD set to: " + APPWD);

      connectToWiFiAP(APName, APPWD);
   } else if (data.startsWith("SET_BaseURL:")) {
      logMessageln("SET_BaseURL command found!");
      BaseURL = data.substring(12);
      logMessageln("BaseURL set to: " + BaseURL);
   }
}

String readSerial() {
   String serialData = "";
   if (Serial.available()) {
      serialData = Serial.readStringUntil('\r\n');
   }

   serialData.trim(); //THIS IS IMPORTANT TO AVOID ISSUES WITH ENDING /r/n
   return serialData;
}

void sendDataToWiFi(String data) {
   logMessageln("sendDataToWiFi('" + data + "'); (Length: " + String(data.length()) + ")");
   if (BaseURL == "") {
      logMessageln("BaseURL Not Defined! use SET_BaseURL:http://host:port/route/resource command to set it up");
      return;
   }

   HTTPClient http;
   String urlToCall = BaseURL + "?" + data;
   logMessageln("URL to call: " + urlToCall);

   logMessageln("http.begin(" + urlToCall + ")");
   http.begin(urlToCall); //HTTP

   logMessageln("Request: GET " + urlToCall);
   int httpCode = http.GET();
   logMessageln("http.GET() executed!" );

   // httpCode will be negative on error
   logMessageln("HTTPCode: " + String(httpCode));
   if (httpCode > 0) {
      // HTTP header has been send and Server response header has been handled
      // file found at server //200 098
      if (httpCode == HTTP_CODE_OK) {
         String payload = http.getString();
         logMessageln("RESPONSE PAYLOAD: ");
         logMessageln(payload);
         logMessageln("------------------");
      } else {
         logMessageln("HTTP Code is not " + String(HTTP_CODE_OK));
      }
   } else {
      logMessageln("[HTTP] GET... failed, error: " + http.errorToString(httpCode));
   }

   http.end();
}

void logMessageln(String message) {
   if (DEBUG_MODE) {
      String timestamp = String(millis());
      Serial.println(timestamp + "-" + message);
   }
}


 

 

 

 

 

 

ZUMMOBOT – Captura Masiva de Datos para Análisis

13 Mar 18
Jose Nunez
, , ,
No Comments

Resumen Experto

Una de las más importantes tareas en el ámbito de la robótica y de la inteligencia artificial es la captura masiva de datos y su posterior análisis.

Este artículo muestra una aproximación a esta tarea mediante el uso de una red local WiFi, un servidor de bajo costo (Up Board + LAMPP) y controladores basados en ARDUINO con capacidades WiFi. La idea es tener la capacidad de subir al upboard muchos datos por segundo desde el ARDUINO y poder descargarlos en formato CSV para su posterior análisis y la capacidad de observarlos en tiempo real.

Los componentes funcionales de esta solución incluyen lo siguiente par aun total de $106 a $186:

  1. Sensor de color Flora TCS34725 ($10 @ crcibernetica )
  2. Microcontrolador Sparkfun Thing ESP8266 ($16 @ crcibernetica)
  3. Enrutador WiFi (Cualquier enrutador 802.11 b/g/n podría servir $29 @ amazon)
  4. UpBoard 4GB RAM, 32GB Storage ($130 @ upboard-shop) (Tambien podría servir un Raspberry PI3 de $55 de crcibernetica)

Pasos Resumidos:

  1. Configure el enrutador para generar una red WiFi convencional. El microcontrolador usará una dirección IP asignada por el enrutador de forma dinámica mientras que el UpBoard usará una estática.
  2. Instale Ubuntu Mate 16.04 en el UpBoard
    • Instale también XAMPP
    • Configure el UpBoard y para usar una dirección de red estática en la red WiFi. Ejemplo 192.168.0.3
    • Instale la aplicación PHP “zummobotdb” en el upboard (/opt/lampp/htdocs/zummobotdb). Esto haría que exista un sitio web en http://localhost/zummobotdb desde donde se puede subir y descargar los datos.
      • Esta aplicacion PHP ofrece las siguientes funciones:
        • set.php: Endpoint de tipo GET para persistir datos de manera dinámica usando valores suministrados por querystring.
        • getcsv.php: Endpoint de tipo GET para extraer todos los datos almacenados usando un archivo descargable en formato CSV
        • getcsv_last.php: Endpoint de topo GET para extraer una cantidad determinada de registros de la base de datos. El formato del resultado es CSV pero no genera un archivo descargable en el navegador.
        • realtime.php: Página utilitaria que permite monitorear en tiempo real los últimos 15 registros almacenados en la base de datos.
        • ** En el futuro estaremos agregando nuevas funcionalidades y modificando este artículo.

    • Utilice phpMyAdmin para crear la base de datos zummobotdb usando el script correspondiente. Dicho script se ubica en zummobotdb/DA/dbscript.sql
  3. Abra el  sketch de Arduino IDE para leer el sensor y subir los datos a la red WiFi y súbalo al Sparkfun Thing ESP8266.
    • En el momento en que se activa el sketch, el Sparkfun Thing tratará de conectarse a la red WiFi especificada y empezar a enviar datos de manera masiva.
    • Nosotros pudimos medir una subida de 230 datos por segundo para datos estáticos y de 40 lecturas por segundo para datos del sensor de color.

Introducción al ESP8266

31 May 17
Jose Nunez
, , , , ,
one comments

Aquí resumo algunas cosas que he ido descubriendo del ESP8266 esta semana:

#1 – El ESP8266 viene programado de manera nativa con un firmware que responde a comandos AT para realizar conexiones y comunicación WiFi. Una referencia útil al set de comandos se puede encontrar acá.

#2 – El ESP8266 puede ser programado mediante el IDE de ARDUINO. Para esto es necesario instalar la definición de placa usando la opción de Tools > Board Manager; pero antes de esto es necesario configurar la siguiente URL para definición de tarjetas adicionales usando la opción File > Preferences > Additional Boards Manager URLs.

URL:  http://arduino.esp8266.com/stable/package_esp8266com_index.json

Es necesario cerrar el IDE y volverlo a cargar para poder utilizar el board que aparece en la lista abajo como “Generic ESP8266 Module“. (!) Importante: Una vez re-programado el módulo se pierde el firmware que habilita los comandos AT. Para re-habilitarlos será necesario seguir alguno de los procedimientos disponibles para cargar el firmware

#3 – Se puede conectar el módulo directamente a la PC usando un convertidor USB-Serial FOCA 2.2 con las siguientes conexiones; pero antes se debe configurar el FOCA 2.2 para operar a 3.3V, caso contrario se daña el ESP8266:

esp8266_pinoutFOCAV2.2        ESP8266
   VCCIO -----> VCC (3.3V)
     TXD -----> RXD
     RXD <----- TXD
     GND <----- GND
   VCCIO --R*-> CH_PD

R* es un resistor de 3KOhm

 Opcionalmente se enciende el dispositivo con el GPIO0 conectado a tierra (GND) para habilitar la descarga de sketches de ARDUINO en el módulo; y luego se desconecta de GND para operar con el Sketch descargado.
FTDI Cable             ESP8266
 VCCIO (red)    -----> VCC (3.3V) 
   TXD (orange) -----> RXD 
   RXD (yellow) <----- TXD
   GND (black)  <----- GND
 VCCIO (red)    --R*--> CH_PD

#4 – La definición de placa del ESP8266 de ARDUINO (“Generic ESP8266 Module“) incluye una cantidad importante de ejemplos muy básicos para la operación del módulo, ya sea como Cliente HTTP, o cliente WiFi, o Access point, e incluso la creación de redes tipo Mesh usando WiFi.

#5 – El módulo ESP8266 no tiene capacidad para comunicarse con servicios de Internet por canales seguros de tipo HTTPS, lo cual representa una limitante sobre el tipo de aplicación que se pueda implementar. Como medida mínima es recomendable conectar el ESP8266 a un IoT Gateway con capacidad de comunicación HTTPS hacia la nube y no usarlo en aplicaciones suceptibles en caso de ser “hackeadas” ya que es relativamente facil para un hacker poder interceptar los datos provenientes del ESP8266 (no cifrados) interpretarlos e incluso suplantarlos.

#6 – El ESP8266 se puede conseguir en Costa Rica en CR Cibernetica. Nótese que al momento de escribir este artículo el precio estaba en $7.95, solamente $1 por debajo del SONOFF que aparte de traer uno de estos módulos tiene el hardware necesario para manejar corriente AC y un programa predeterminado para poder operarlo mediante un App de teléfono.

#7 – En Amazon se puede conseguir hasta por $15 cuatro módulos ($3.75 cada uno!). En Wish.com se pueden conseguir incluso a $2. Aunque para ser sinceros la comodidad de comprarlos en CR Cibernética y que me los traigan a domicilio el día siguiente es inigualable.

 #8 – Volviendo a los comandos AT, se puede acceder a estos mediante una terminal como Putty usando el puerto serial del FOCA V2.2 a una velocidad de 115200 bauds, pero es necesario (al menos en el caso de Putty) utilizar [ENTER] y [CTRL]+[ J ] para enviar los comandos al módulo y obtener una respuesta. Una conexión parecida se puede usar desde un ARDUINO 101 (que opera a 3.3V) usando la librería SoftwareSerial para operar el ESP8266 usando comandos AT enviados desde el ARDUINO. También se puede operar el ESP8266 desde un arduino usando los GPIO del ESP8266 como indicativos de qué hacer y que un Sketch de ARDUINO en el ESP8266 tome decisiones y realice comunicaciones WiFi basadas en esas señales.

#9 –  Finalmente cabe mencionar que el módulo tiene la capacidad de almacenar información en estado apagado. Lo cual permite, por ejemplo, recordar cual fue el último SSID/Passphrase que se usó y reconectar al encender, tanto para aplicaciones basadas en comandos AT como para aplicaciones basadas en sketch de Arduino ejecutados en el módulo ESP8266.

Comenzando con Intel Edison en UBUNTU

17 Feb 16
javilargo
, , ,
No Comments

Descripción2112-00

Este procedimiento describe a groso modo cómo comenzar a utilizar la placa Intel Edison con tarjeta de expansión ARDUINO, programándola desde una Laptop  que corra UBUNTU LINUX.


Procedimiento

PASO 1 – Descargar el programa aquí
Descomprimir el archivo e instalar el script install_GUI.sh por medio de la terminal de Ubuntu. También instalar Intel Phone Flash Tool Lite, que viene incluido a la hora de instalar el programa (en el directorio del programa)

sudo ./install_GUI.sh

sudoinstalsh


PASO 2 – Conectar la placa Intel Edison mediante una conexion serial (Ej: usb). en este caso se utilizará la conexión que permite el uso de arduino, además de la placa conectada a una fuente de corriente. Se debe considerar: la pc en la mayoria de los casos no brinda suficiente corriente para alimentar la placa por lo que es mejor conectarlo a una fuente de energia estable.
Igualmente las conexiones que se utilizan para conectar al USB de la PC, la placa edison, son las conexiones micro USB, el mini switch en la placa debe seńalar hacia los puertos micro USB. estos puertos en la placa serán representados como a) y b) ya que tienen funciones diferentes. En todo caso se pueden conectar ambos micro usb simultaneamente a la PC.
a) A la hora de conectar cada micro USB se nota la diferencia en que uno, al conectarlo a la pc, aparecera como un dispositivo removible en esta, esta conexion sirve para subir funciones desde el programa de arduinos
b) En la otra conexion micro USB al conectarse a la PC no aparecera como un dispositivo removible, esta conexión es la que sirve para trabajar en la placa desde la terminal de Ubuntu.

  1. Para este paso se necesita screen shell en ubuntu en caso de no tenerlo utilizar el siguiente comando en la terminal
sudo apt-get install screen

Conectar el Edison desde la conexion micro usb b) (ver punto 2)
Para conectar la placa ingresar el siguiente comando (donde ttyUSB0 es el dispositivo)

sudo screen /dev/ttyUSB0 115200

Después de escribir este comando darle Enter, en algunas ocasiones se le debe dar enter 2 veces.
La terminal nos pedirá un login aqui, escribir ¨root¨ (sin comillas)
Se solicitará la contraseńa del sistema. Ingresarla y darle Enter
Debe quedar un mensaje similar a este:

terminal


PASO 3 –  Conectar la placa Intel Edison a internet mediante WI-FI utilizando el comando:

configure_edison --wifi

En caso de que ocurra el error en el que no se encuentra la Placa Edison (configure_edison: not found) se debe utilizar la aplicacion Intel Phone Flash Tool para preparar el dispositivo.     Aceptar y darle enter para continuar. Aparecera una lista con las conexiones WI-FI disponibles, cada una con un numero, el cual debemos ingresar para elegir la conexion a la cual se quiere accesar, ingresar los credenciales de la red. Aparecerá el mensaje ¨done¨ . La placa ya esta conectada a internet y se puede observar que aparece la dirección IP de esta en la terminal, se puede comprobar la conexión mediante el comando ¨ping¨ en la terminal.


PASO 4 – Completar el setup de la aplicación descargada para que se instalen los programas, se instalará el programa arduino e Intel Phone Flash Tool Lite.
En este caso se utilizó, como se dijo anteriormente el lenguaje Arduino como IDE en la aplicación instalada. Esta aplicación se corre como administrador mediante el comando:

sudo arduino

En este caso, se debe conectar al puerto micro USB a) para subir funciones a la placa


Notas *Recordar ejecutar el programa como administrador a la hora de abrirlo, de lo contrario el acceso será denegado

**Fijarse que el puerto seleccionado en la aplicación sea el adecuado, es decir que concuerde con el que se esta utilizando en la conexion serial y utilizar el correcto Addon para cada dispositivo que se este utilizando. En la aplicación donde dice ¨tools¨ revisar: Port que esté seleccionado el que se esta utilizando y Board que se esté utilizando el que concuerde con el dispositivo (En el caso del Edison, ya viene en la aplicación se selecciona Edison)

***Esta es una versión en espańol para comenzar a utilizar la placa Intel Edison. La versión original (en inglés) puede encontrarse en la siguiente dirección: https://software.intel.com/en-us/get-started-edison-linux-step1

Edison – Linux – Cómo restablecer la conexión de Red

01 Sep 15
José Núñez
, , , , , ,
No Comments

En otra publicación veíamos que para reiniciar la conexión de red en GALILEO se usaba un comando de init.d

Para Edison es diferente. Dado que Edison no usa init.d, hay qu usar otro tipo de comando para reiniciar:

1. Reiniciar la red:
systemctl restart wpa_supplicant.service

2. Verificar el estado del servicio de red:
systemctl status wpa_supplicant.service

o tambien…

ping google.com