Tag Archives: Arduino IDE

IMG_20160713_154251

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

13 Jul , 2016,
Jose Nunez
, , , ,
one comments

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.

2112-00

Comenzando con Intel Edison en UBUNTU

17 Feb , 2016,
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

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

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