Conceptos – Investigación

Muchas veces hemos escuchado frases como “Ya lo investigué en google”, o en Internet para no hacerle publicidad a ningún buscador en particular. :o)

Para efectos de la cultura Maker, investigar va más allá, consiste en buscar comprender la forma en que algo se realiza, usando recursos como el Internet, libros, revistas, artículos y también mediante la ejecución de experimentos, prueba y error.

Uno de los factores que suele dejarse de lado es el factor de documentación. Ninguna investigación estará completa si no documentamos los hallazgos, los resultados de lo que hemos investigado; aquello que aprendimos; y no estará completa si no publicamos dicha documentación para que otros, ya sea de manera libre o mediante un rédito monetario, puedan acceder a ese conocimiento.

La comunidad Costa Rica Makers pretende facilitar el proceso de investigación ofreciendo – en español – recursos como blogs, publicaciones y eventos que permiten a los ticos adentrarse en el maravilloso mundo de la creación de cosas y de conocimiento nuevo.

Eso que “googleaste” ¿ya lo publicaste?

Afinidad entre el tico y la cultura Maker / DIY

imageMi papá suele parafrasear a mi abuelo en una frase: “¿Quién le enseñó al primero que lo hizo?“. Con esto nos da a entender que el ser humano no se puede limitar a solamente aprender y usar lo que está hecho; sino que puede de manera creativa inventar nuevas cosas y crear nuevo conocimiento.

Todos hemos escuchado el término “Maguiverazo”; es la forma en que llamamos los ticos al conocido “hack”.

Pienso que el tico, especialmente los jóvenes contemporáneos son particularmente creativos y efectivos en la tarea de entender un problema y buscarle una solución, aunque para ello se necesite reinventar el agua tibia.

Obviamente no queremos fomentar la reinvencion reiterada del agua tibia sin valor agregado alguno; pero pienso que esa actitud de “tal como está no me sirve”, y de “mejor lo hago yo” calza perfectamente con la actitud necesaria para cosechar una cultura de hacedores (Makers/DIY) que cuestionen constantemente lo que la tecnología actual no nos brinda, y lo cuestionen de manera efectiva, diseñando, prototipando y llevando a producción soluciones alternativas capaces de superar a las existentes.

Mi padre, tiene otra frase famosa: “¿Quién dice que las cosas no se hacen?“, la cual usa cada vez que tiene éxito en algún invento o proyecto suyo.

Hoy lanzamos a la luz esta iniciativa de ir y buscar a esos inventores de todas las edades; y ponernos a conversar, y colaborar y hacer de este país y de este mundo de por sí globalizado un mejor lugar para vivir.

¿Qué vamos a inventar hoy? ¡Uyuyúy Bajura!

Humidity and Temperature Sensor DHT11 on Intel Galileo

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

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