Tag Archives: Intel Galileo

Sensor de Humedad DHT11 en un Intel Galileo

9 Mar , 2015,
José Núñez
, , , , , ,
one comments

IMG_20150309_183311~2

Conectar un sensor de humedad y temperatura a un Intel Galileo o Edison no es tan sencillo como uno quisiera; pero luego de preguntar en los foros adecuados, tampoco es difícil.

Aquí les comparto lo que aprendimos en el proceso (hasta hora)

  1. El DHT11 es un sensor sumamente barato y fácil de conseguir. Tiene una excelente precisión y es fácil de utilizar.
  2. Pudimos comprobar las instrucciones de DinoT_Intel en el foro, que funcionan en un Intel Galileo GEN 1
  3. Básicamente uno puede bajar los tres archivos (como lo tenemos en nuestro experimento más reciente en GITHUB) en una misma carpeta donde está el Sketch que y funciona correctamente. Tambien se puede crear una carpeta “DHT” en “~/Arduino_version/libraries/” y poner los dos archivos DHT.h y DHT.cpp ahi (pero necesitarás reiniciar ARDUINO IDE)
  4. Nuestras pruebas funcionaron en un Galileo GEN 1 a la perfección usando ARDUINO IDE versión [arduino-1.5.3-Intel.1.0.4] que se puede descargar aquí.
  5. IMPORTANTE: Utilizar 7ZIP para desempacar el achivo en c: … puede conseguirlo aquí.

Esta vez no logramos echarlo a andar en Intel Edison. Ya les contaremos si llegamos a ese punto.

Un agradecimiento especial a @spider_kenny por su contribución de conocimiento sobre tiempos determinísticos e interfases. Creo que será la base que usaremos para echarlo a andar en un Intel Edison.

Llamadas dinámicas a LINUX desde ARDUINO IDE en un Intel Edison – Aprendizaje de 10 minutos

7 Mar , 2015,
José Núñez
, , , , , , , , ,
3 comments

IMG_20150307_170030

Uno de los súper poderes de las plataformas Edison y Galileo de Intel es la disponibilidad de LINUX y la posibilidad de ejecutar comandos de LINUX desde un “sketch” de ARDUINO.

En esta receta les comparto cómo hacer llamadas dinámicas al sistema de LINUX desde un sketch ARDUINO, concatenando valores en un objeto String y luego convirtiendo dicho objeto a un arreglo de caracteres necesario para la llamada de sistema.

La idea es poder concatenar comandos de sistema, con valores leidos de los sensores, y hacer llamdas a Linux para que haga algo a partir de estos valores.

En resumen:

  1. La llamada de sistema recibe un parámetro que es un arreglo de caracteres (no un String)
  2. La concatenación se puede hacer de manera muy sencilla usando un String
  3. La conversión se realiza creando un arreglo de caracters del tamaño del String mas un caracter terminador.
  4. El sketch abajo es una modificacion del ejemplo BLINK, que además de hacer parpadear un led, tiene un contador que lleva la cuenta de la cantidad de veces que se ejecuta el comando loop().
  5. La función “dynamicCommand(c)” recibe el valor del contador y genera un comando de sistema para realizar un listado del contenido de una carpeta y poner el resultado en un archivo. Este archivo es nombrado con un sufijo que indica la cuenta que lleva el contador.
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;
int c = 0; //just a counter

// the setup routine runs once when you press reset:
void setup() {                
    // initialize the digital pin as an output.
    pinMode(led, OUTPUT);    
    Serial.begin(9600);
    Serial.println("TEST FOR STRING CONCATENATION"); 
}

// the loop routine runs over and over again forever:
void loop() {
    c++; //un simple contador
  
    Serial.println("Count: ");  
    Serial.println(c);

//  Serial.println("Count: " + c); //This behaves weird...  
    
    if( c < 10){ 
         dynamicCommand(c);
    }
    Serial.println("Blinking...");
    digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
    delay(1000); // wait for a second
    digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
    delay(1000);               // wait for a second
    Serial.println("Loop Complete!"); } 

dynamicCommand(int counter){
     Serial.println("dynamicCommand function..."); 
     String command = "ls > resultFile";
     command += counter;
     command += ".log";
     Serial.println("Concatenated command looks like this:");
     Serial.println(command);

//UPDATE: THIS COULD BE ACHIEVED USING THE buffer propery of the String object
//     Serial.println("Converting to char array...");
//     int commandLength = command.length() + 1;
//     char commandCharArray [commandLength];
     
//     command.toCharArray(commandCharArray, commandLength);
     
//     Serial.println("Command array looks like this:");
//     Serial.println(commandCharArray);
//     Serial.println("Making system call...");
//     system(commandCharArray);


system(command.buffer);

Serial.println("Done!"); }

Intel Galileo – Enviar datos a un sitio web usando NodeJS

29 Oct , 2014,
José Núñez
, , , , , ,
8 comments

Espero en unos días publicar un tutorial más completo sobre el uso de NodeJS en Intel Galileo.

Por el momento les presento este código de prueba.

var request = require('request'); //Referencia a la librería "request" de nodejs
var i = 0; //variable para contar
var timer = {};
test();
function test(){
   i++;
   var busqueda='costa rica makers';
   var url= 'http://www.google.com/';
   url += '?q=' + busqueda;
   url += '&veces=' + i; //un parametro adicional cualquiera

   request(url , function (error, response, body){
      if (!error && response.statusCode == 200) { //EXITO
         console.log(body);
      } else { //ERROR
         console.log(response);
         console.log(error);
      }
   timer = setTimeout(test,2000); //VOLVER A LLAMAR EN 2 SEGUNDOS
 });
}

Configurando nodeJS y la librería Request

Para que el script anterior funcione, la libreria request debe estar disponible. Digamos que creamos una carpeta particular para la prueba: ~/nodejs_test01 ( o lo que es lo mismo /home/root/nodejs_test01/)

Para esto es necesario instalar la libreria usando la utilidad npm, pero para esto es necesario tambien que el Galileo tenga la fecha y hora correctas.

Entonces, ejecute estos pasos en el linux del Galileo:

date 1029114114
El comando anterior, configura la fecha del galileo a OCT-29-2014, a las 11:41 de la mañana. Si su fecha/hora fuera el primero de diciembre de 2014 a las 3:30pm podria ejecutar esto:  date 1201153014  donde los cuatro primeros caracteres son DIC-01, los siguientes cuatro caracteres son 15:30, y el ultimo juego de dos caracteres es el año 2014.

npm install request
Esta operación puede tardar varios minutos, básicamente descarga la libreria del repositorio de NPM

wget http://costaricamakers.com/wp-content/uploads/2014/10/test_request.js
Esto descarga el programa test_request.js en la carpeta seleccionada.

Ejecutando el programa

Para ejecutar el programa, primero almacénelo en la carpeta de pruebas que hicimos “~/nodejs_test01/request_test.js”

Luego ejecute el siguiente código:

node request_test.js

Listo, el programa empezará a llamar al sitio web de google con la pregunta “costa rica makers”

Para detener el programa utilice las teclas CTRL+C

Humidity and Temperature Sensor DHT11 on Intel Galileo

9 Mar , 2014,
José Núñez
, , , ,
No Comments

IMG_20150309_183311~2

Para la versión en Español Haz Clic Aquí

 

Connecting a Humidity and Temperature Sensor to an Intel Galileo or Edison board is not as simple as one would like; but after looking into the right forums, it is not difficult either, took us 1 day to realize.

So here we share what we learned in the process (so far).

  1. The DHT11 is a very cheap and easy to find sensor. It has great precision and it is easy to utilize.
  2. We were able to prove to ourselves that instructions provided by DinoT_Intel in the forum work in an Intel Galileo GEN 1
  3. Basically we can download the three code files as we did in our most recent experiment in GITHUB) into one single folderwhere the Sketch resides; and it will work fine. You can also create a folder “DHT” in “~/Arduino_version/libraries/” and place the two files DHT.h y DHT.cpp there (but you’ll need to reload the IDE)
  4. Our tests worked in a Galileo GEN1 perfectly using an ARDUINO IDE version [arduino-1.5.3-Intel.1.0.4] that we downloaded here.
  5. IMPORTANT: Use 7ZIP to extract the arduino IDE from the file into c: … you can download 7ZIP here.

This time we were not able to make it work in an Edison; but we’ll tell you when we get to that point.

Special thanks to @spider_kenny for his contribution of knowledge about deterministic time devices and interfaces. I think it will be the foundation we’ll use to make it work in EDISON.

Dynamic calls to LINUX system from an ARDUINO sketch in Intel Edison – 10 minutes learning

7 Mar , 2014,
José Núñez
, , , , , , ,
3 comments

IMG_20150307_170030

Spanish Version Here

One of the many super-powers of Galileo and Edison platforms from Intel is the availablity of LINUX and the possibility of executing LINUX commands from an ARDUINO sketch.

In this recipe I am sharing how to make dynamic calls to LINUX from an ARDUINO sketch, concatenating values in an String object and then converting such object into a char array, needed to make system() calls.

The idea is to be able to concatenate system commands with sensor values and make calls to the LINUX OS to do something based on those values.

In summary:

  1. The system() function receives a char array parameter (not a String)
  2. Concatenation is very easy to do in String objects
  3. Conversion is made by creating a char array of the size of the command string plus one ending character.
  4. The sketch below is a modification of BLINK sample, that has a counter for how many times loop() function is executed.
  5. The function “dynamicCommand(c)” receives the value of the counter (it could be a sensor reading instead) and generates a command to LINUX system to do a folder listing into a file whose name is crafted based on the cunter value.

Enjoy!

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;
int c = 0; //just a counter

// the setup routine runs once when you press reset:
void setup() {                
    // initialize the digital pin as an output.
    pinMode(led, OUTPUT);    
    Serial.begin(9600);
    Serial.println("TEST FOR STRING CONCATENATION"); 
}

// the loop routine runs over and over again forever:
void loop() {
    c++; //un simple contador
  
    Serial.println("Count: ");  
    Serial.println(c);

//  Serial.println("Count: " + c); //This behaves weird...  
    
    if( c < 10){ 
         dynamicCommand(c);
    }
    Serial.println("Blinking...");
    digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
    delay(1000); // wait for a second
    digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
    delay(1000);               // wait for a second
    Serial.println("Loop Complete!"); } 

void dynamicCommand(int counter){
     Serial.println("dynamicCommand function..."); 
     String command = "ls > resultFile";
     command += counter;
     command += ".log";
     Serial.println("Concatenated command looks like this:");
     Serial.println(command);
     
//UPDATE: THIS COULD BE ACHIEVED USING THE buffer propery of the String object
//     Serial.println("Converting to char array...");
//     int commandLength = command.length() + 1;
//     char commandCharArray [commandLength];
     
//     command.toCharArray(commandCharArray, commandLength);
     
//     Serial.println("Command array looks like this:");
//     Serial.println(commandCharArray);
//     Serial.println("Making system call...");
//     system(commandCharArray);

system(command.buffer);
Serial.println("Done!"); 
}