Intel Edison – Análisis de Datos con Lenguaje “R” mediante UBILINUX (nota rápida)

IMG_20170120_183547Durante 2016 hicimos varios proyectos interesantes con Intel Edison.

Uno de ellos fue un proyecto de colaboración con nuestros colegas de UNED en la investigación de sonido ambiente mediante tecnologías IoT.

Una de las cosas más interesantes que pudimos experimentar fue esta idea de hacer análisis de grabaciones de sonido mediante la plataforma Intel Edison y el lenguaje de “Machine Learning” llamado “R”

Esperamos detallar más aun el proceso en próximas entregas. Por lo pronto les dejamos con un tutorial de Sparkfun sobre cómo instalar UBULINUX, una versión de LINUX para IoT basada en DEBIAN en el Edison. La ventaja de esto es que se puede usar el sistema de paquetes APT-GET para instalar el lenguaje “R”

https://learn.sparkfun.com/tutorials/loading-debian-ubilinux-on-the-edison

Pese a que los desarrolladores de UBILINUX se lamentan de no tener soporte suficiente para esta herramienta; creo que vale la pena probar y ayudar un poco a generar ese ecosistema.

Intel Joule – Primeros Pasos

___fadd2efe-349e-4ec3-b03e-b6fbd6b6ebfe-imageId=0a6ed59a-7a19-4839-b801-9691e0c0ae4a (1)En nuestra publicación anterior hicimos un breve recorrido sobre las especificaciones del Joule de Intel, una tarjeta de desarrollo pensada para adentrarnos en el mundo de las aplicaciones de alta demanda computacional en dispositivos pequeños, ya sea vestibles o de tamaño reducido; especialmente sistemas de análisis de imágenes 3D de cámaras Intel Real Sense.

En esta ocasión iremos paso a paso por los tutoriales de Intel sobre cómo empezar a desarrollar soluciones en esta magnífica plataforma.

Para esto nos basaremos en la guía de usuario suministrada por el fabricante mientras tratamos de resumir y enfocarnos en los aspectos más importantes.


1 Materiales Requeridos

Comencemos por los diferentes materiales que serán necesarios para nuestro primera incursión funcional.

  1. Una Plataforma de Desarrollo Intel Joule 570x (enlace)
  2. Un disipador de calor (suministrado con la plataforma)
  3. Fuente de poder 12V, 3A (En este tutorial nosotros usamos una de 12V, 2A) conector de barril de 5mm con centro positivo de 2.1mm
  4. Cable micro-USB tipo B para la comunicación serial con el dispositivo (cable no incluido en el kit). Es el tipo de cable con que actualmente cargamos los telefonos Andriod.
  5. Teclado USB. Nosotros utilizamos un teclado inalámbrico con ratón marca Microsoft sin mayor problema.
  6. Cable HDMI macho estándar a macho conector micro
  7. USB Hub: Opcionalmente un concentrador USB (hub) con suministro eléctrico independiente (en caso de querer conectar dispositivos que demanden más de 900mA)
  8. Bluetooth: Opcionalmente también se pueden conectar dispositivos de teclado y ratón vía Bluetooth.
  9. Computador Anfitrión: Se necesitará un computador para programar el Joule.
    • Para actualizar el BIOS del Joule será necesario un computador anfitrión con sistema operativo Windows 8, 8.1 o Windows 10.
    • El sistema operativo que se vaya a utilizar en el Joule introduce algunas dependencias en el computador anfitrión que se use para programarlo. Así, si se utiliza LINUX de referencia que provee Intel o si se utiliza Ubuntu para IoT, se puede usar un computador anfitrión con sistema operativo Windows, Linux o Mac. Pero si el sistema operativo del Joule es Windows IoT, el computador anfitrión deberá estar equipado con sistema operativo Windows 10 y demás especificaciones de Microsoft descritas acá.

2 Ambientes de Desarrollo de Intel

El Intel Joule se puede programar de muy diversas formas. Intel recomienda usar alguno de los siguientes sistemas para programara la plataforma:

  1. Intel System Studio IoT Edition para Windows, Mac, o Linux en  caso de querer programar la plataforma mediante lenguajes como C/C++ o Java. Nótese Intel System Studio para Linux requiere Ubuntu 16.04 LTS como sistema operativo anfitrión en 64bit.
  2. Intel XDK tambien para Windows, Mac o Linux, en caso de querer programar la plataforma con NodeJS

(!) En esta publicación utilizaremos Intel XDK tanto en un anfitrión Linux (Mint 18) como en Windows 10.


3 Requisitos para Instalación del Sistema Operativo del Joule

La plataforma Intel Joule trae de fábrica una versión optimizada del sistema operativo LINUX. Se recomienda actualizarla ya sea a la imagen más reciente o a alguna versión de Ubuntu Desktop o de Windows for IoT.

Dicha actualización requiere:

  1. Flash Drive de tipo USB 3.0 con 16GB de capacidad conectado a un USB HUB con alimentación independiente. Puede ser USB 2.0 pero la transferecia de datos tendrá una tardanza notoria.
  2. Tarjeta MicroSD de 16GB (puede usarse un Flash Drive adicional si se trata del LINUX de referencia)
  3. El computador anfitrión deberá tener capacidad de leer la tarjeta del punto #2 anterior.
  4. Instrucciones (En inglés) para la actualización del sistema operativo

4 Ensamblando la Plataforma de Desarrollo

Este enlace provee instrucciones muy completas y sencillas sobre cómo preparar / ensamblar los diferentes elementos de la plataforma desarrollo. Se incluyen en dicho enlace pasos importantes como:

  1. Instalación del disipador de calor
  2. Antenas
  3. Instalación de espaciadores

5 Sobre el sistema operativo de la plataforma

En este enlace se describe en detalle las principales opciones de sistema operativo las cuales incluyen:

  1. Ubuntu Desktop 16.04 LTS
  2. Ubuntu Core 16.04 LTS
  3. Windows 10 IoT Edition
  4. Linux de referencia para IoT

6. Actualizando el BIOS

Un primer paso importante en el uso de Joule consiste en actualizar el BIOS. Es el software que orquesta ya carga del sistema operativo y otras funciones de entrada/salida.

El procedimiento es realmente sencillo, nos ha tomado unos 20 minutos en realizarlo. Se describe en este enlace:

https://software.intel.com/en-us/flashing-the-bios-on-joule


7. ¿Qué sigue?

En nuestra siguiente entrega estaremos explorando la instalación de Windows 10 for IoT en el Joule.

Robot de dos llantas + acelerómetro/giroscópio > Una experiencia de Aprendizaje

robot-willieResumen

Les confieso que esta es mi primera publicación; por pura insistencia de mi editor estamos acá escribiendo. En esta primera entrada discutiremos mi experiencia en Intel en la investigación de cómo programar un robot de dos ruedas mediante diversos micro-c0ntroladores, incluyendo el S4A-EDU, Arduino UNO, Aruduino 101 y Sparkfun Thing.

Detalle

A principios de este año 2017. tuve la bendición de poder pasar unos días en Intel en una experiencia “ad-hoc” de aprendizaje de tecnología, investiación, desarrollo, auspiciada por el Centro de Innovación de Intel y por José Núñez.

En esta experiencia pudimos explorar las diferentes reacciones que que tenia el robot cuando instalábamos diferentes programas (en ARDUINO IDE) con  diferente controladores para realizar rutinas como por ejemplo: movilidad hacia adelante y atrás, movimientos con giros con duración específica y también pudimos ver funcionar el acelerometro y giroscópio del chip Intel Curie.

En el fondo nos concentramos en tratar de entender cómo hacer que se mueva el robot (descrito acá) en distintas direcciones y cómo hacer que este pueda tener un movimiento rectilineo preciso, controlado utilizando el giroscopipo disponible en el Intel Curie.

Experiencia con el Acelerómetro de Intel Curie

Comenzamos aprendiendo sobre las diferentes funciones del Intel Curie. Para esto realizamos diversos experimentos descritos en este artículo de Jose Nunez acá en CostaRicaMakers.com.

La verdad me resultó sencillo de utilizar y muy útil para aprender a hacer las lecturas de los diferentes sensores (acelerómetro y giroscópio) y la utilización de las funciones de Blue Tooth Low Energy (BLE)

Experiencia con el Robot de dos llantas y el controlador S4-EDU

La verdad es que comencé con esta experiencia con altas expectativas de lo que podría aprender y hacer. Al principio el primer problema que enfrenté fue aprender un poco de programación, creo que tengo un largo camino por recorrer en esta área.

El robot en sí permite realizar movimientos de manera muy versatil gracias a su sistema de dos llantas independientes sobre las que podemos controlar dirección individual y velocidad.

Como mencioné antes fuimos probando diversos controladores, comenzando por el original del kit del robot (el S4A-EDU) que cuenta con un circuito muy interesante denominado “Puente H” (H-Bridge) que nos permite controlar la dirección y velocidad de los motores.

Una vez que pudimos hacerlo moverse usando el controlador original (S4A-EDU) nos dimos a la tarea de reemplazar dicho controlador (parcialmente) con un ARDUINO101 que como dijimos tiene sensores de movimiento (acelerómetro y giroscopio). Para esto pudimos facilmente desconectar el puente H del S4A-EDU y conectarlo al ARDUINO 101.

Como dije antes, el principal reto que enfrentamos fue la programación. Realizamos diferentes tipos de programa usando el ambiente integrado de desarrollo (IDE) de ARDUINO.

Una vez controlado por el ARDUINO 101 para realizar los movimientos básicos, el siguiente reto era comenzar a utilizar el giroscopio para leer cuanto se desviaba hacia un lado u otro el robot al caminar en una misma dirección. Para poder extraer los datos (que son muchos) de las lecturas del giroscopio, tratamos inicialmente de subirlos por WiFi a un servidor en Internet. Pare este fin introducimos un controlador más: el SPARKFUN THING.

La programación del SPARKFUN THING es algo “truculenta” ya que requiere una interfase serial para conectar la laptop donde uno escribe el programa y subirla al micro-controlador. Intentamos con un cable tipo FTDI, pero no tuvimos suerte. En resumen no funcionó por que el cable que teníamos no cuenta con línea DTR… (eso me queda pendiente de entenderlo mejor). Al día siguiente conseguimos otra interfase denomiada “FOCA V1.2” la cual permite comunicación serial con diversas opciones, con y sin línea DTR, a diferentes voltajes (3V, 5V) etc.

Ahora bien, subir datos por via WiFi a un servidor en Internet, el tiempo minimo que toma son 3 o 4 segundos… y el giroscopio generaba datos cada 200ms o menos… o sea, no nos servía la opción del WiFi… fue entonces cuando decidimos cambiar la solución. En vez de guardar los datos en Internet nos avocamos a graficarlos en mi celular usando una conexion Bluetooth Low Energy (del ARUDINO 101). Para esto fue necesario instalar una app en mi celular denominada nRF Toolbox descrita en el artículo mencionado sobre ARDUINO 101.

En este punto logramos que el robot se moviera en una misma dirección durante dos segundos y graficar durante ese tiempo las lecturas del giroscópio cada 200ms.

Control de Velocidad

Aprendí que la velocidad del robot se puede controlar mediante un método que se llama PWM (Pulse Width Modulation) y la idea es utilizar ese principio para ajustar la velocidad de cada rueda para compensar micro-desviaciones del movimiento rectilineo que queriamos lograr. Desafortunadamente no nos dio tiempo de implementar esa parte correctiva.

Conceptos Relacionados

Quiero listar acá algiunos conceptos que me parece importante profundizar en el futuro para mi propio aprendizaje en el área de robótica, tecnología y mecatrónica:

  • Variables y Constantes
  • Funciones y Métodos
  • Pasos e Instrucciones
  • Condicionales
  • Vibración
  • Frecuencia
  • Ancho de Pulso
  • Voltaje
  • Corriente/Amperaje

Agradecimientos

Quiero agradecer a el Señor Jose Núñez por permitirme esta oportunidad de estar en Intel aprendiendo mediante estos experimentos. Sinceramente me ha servido de mucho, tanto para mis estudios como para mi futuro.

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);
}

[SOLUCIONADO] Intel Edison – Carga automática de sketch ARDUINO falla en versión 159 del firmware

A esta fecha (31-MAR-2016) nos topamos con la sorpresa de que al actualizar la versión del Firmware de Intel Edison a la #159.devkit (o simplemente 159) deja de funcionar adecuadamente la ejecución de sketches de Arduino al momento de reiniciar el dispositivo.

Todavía más sorprendente el hecho de que las nuevas tarjetas Intel Edison que compramos esta semana vienen con la versión 159 pre-instalada… y con el defecto.

Buscando resolver el problema, nos encontramos una entrada en el foro de Intel donde se explica una solución temporal, que consiste obtener los archivos de la versión 146 y copiarlos a la versión 159.

(!) Para facilitar el proceso hicimos una copia de los archivos en GITHUB. Seguidamente mostramos los pasos simplificados usando esta copia. 


PASO 1: Sobre-escribir los cuatro archivos contenidos en /opt/edison/ con los de la versión anterior (146) o usando los archivos en github

Para descargar los archivos al Edison se pueden usar varios métodos, uno es mediante un cliente SCP/SFTP como WinSCP; otro sería utilizando el comando wget desde el Edison si este está conectado a la Internet via WiFi así:

rm /opt/edison/* -rf

wget -O /opt/edison/clloader https://github.com/janunezc/edison_workshop/blob/master/159_fix/edison/clloader?raw=true

wget -O /opt/edison/launcher.sh https://raw.githubusercontent.com/janunezc/edison_workshop/master/159_fix/edison/launcher.sh

wget -O /opt/edison/sketch_reset https://github.com/janunezc/edison_workshop/blob/master/159_fix/edison/sketch_reset?raw=true

wget -O /opt/edison/sketch_reset.sh https://github.com/janunezc/edison_workshop/blob/master/159_fix/edison/sketch_reset.sh

PASO 2: Darle permiso de ejecución a los programas necesarios con el comando

  • chmod +x /opt/edison/clloader
  • chmod +x /opt/edison/launcher.sh
  • chmod +x /opt/edison/sketch_reset
  • chmod +x /opt/edison/sketch_reset.sh

PASO 3: Ejecutar los comandos de configuración para la auto-carga de sketches de Arduino

  • cd /opt/edison
  • systemctl enable clloader
  • systemctl start clloader

PASO 4: Rebootear de manera segura el Edison con el comando shutdown now


PASO 5: Cargar un sketch de Arduino en el Edison (por ejemplo Blink) y rebootearlo de manera segura con el comando reboot now.


PASO 6: Verifique que el sketch carga luego de apagar completamente el Edison y volverlo a encender.


FIN