Category Archives: Sin Categorizar

Usando la memoria FLASH del Intel Curie

24 Jul , 2017,
Jose Nunez
, ,
No Comments

Hola a todos.

Este es un tópico un poco más detallado.

El siguiente Sketch que pueden descargar de mi Github permite registrar datos en la memoria FLASH (persistente) del Intel Curie, buscarlos y eliminarlos.

Espero que el código sea bastante legible para todos.

Esta es una versión corregida del código original. Resulta que la librería SerialFlash no permite reutilizar porciones de memoria, así que después de varias operaciones creando y removiendo el archivo la memoria se acaba y se hace necesario borrar toda la flash (proceso que toma 1 segundo). Puede observarse en la línea 373 cómo se realiza este borrado cuando la creación “rápida” del archivo falla.

Acá implemento varias técnicas de “debugging” tales como parpadeos informativos, mensajes de consola estructurados y “pruebas unitarias” así como funciones de alcance y tamaño limitado.

Acá se resuelven  varios problemas, incluyendo aquello de ¿Cómo convierto un String a un const char*?  Bueno, no necesariamente una conversión, sino una implementación que es soportada por la función que estaba tratando de llamar. (ver linea 319)

En resumen, acá implemento funciones para crear un archivo en la memoria flash, con un formato predefinido. Leer el contenido de ese archivo y borrar el archivo.

Luego tambien implemento funciones para buscar contenido en el archivo y para eliminar contenido del archivo.

A su vez hay funciones para verificar el formato del archivo y realizar algunas pruebas unitarias.

El caso de uso es el almacenamiento de datos pequeños (códigos de acceso por ejemplo) que se puedan agregar, buscar o eliminar.

Capas:

  1. Acceso a Datos: Manejo de la memoria flash con archivos (crear archivo, guardar contenido, obtener contenido, eliminar archivo)
  2. Negocio: Agregar llave, eliminar llave, buscar llave.
  3. Desarrollo: diferentes pruebas y verificaciones.

Son una veintena de funciones pequeñas. Cada una hace lo suyo de manera muy explícita. Espero que les sea de utilidad.


// Escrito por José Núñez como un ejemplo didáctico para el dominio público.
// Utiliza la librería SerialFlash de Paul Stoffregen.
// Dicha librería se puede descargar de https://github.com/PaulStoffregen/SerialFlash

//Abstracción de la librería SerialFlash para el controlador Intel Curie
#include 
#include 

#define FSIZE 256 //Tamaño predefinido del archivo
#define ledPin 13 //PIN para un LED 
#define buttonPin 10 //PIN para leer un botón. Debe estar "pull-up" y el botón realiza una conexión a tierra.

const char *filename = "rfidble.txt"; //Nombre del archivo
#define CONTENT_SIZE 153 //Tamaño predefinido del contenido del archivo para este ejemplo.

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT);
  
  parpadear (5, 1000);

  debugMessage("Setup() BEGIN!");

  parpadear (3, 500);
  
  // Inicializar operación de la librería SerialFlash
  if (!SerialFlash.begin(ONBOARD_FLASH_SPI_PORT, ONBOARD_FLASH_CS_PIN)) {
    debugMessage("Setup() Unable to access SPI Flash chip");
  }

  debugMessage("Setup() DONE!");
}
/*------*/
/* LOOP */
/*------*/
bool executedOnce = false;
bool addKeyMode = false;
void loop() {
  if (!executedOnce) {
    debugMessage("loop() executing... reading file...");
    String fileContent = readFile();

    debugMessage("loop() file read: |" + fileContent + "| (" + String(fileContent.length()));

    debugMessage("loop() doing file verifications...");
    if (!verifyBegin(fileContent) || !verifyEnd(fileContent) || !verifySearch() || ! verifySize(fileContent)) {
      debugMessage("loop() Verifications Failed. Reformatting...");
      initFile();
      executedOnce = false;
    } else {
      debugMessage("loop() verifications ran OK");

      debugMessage("loop() testing key addition");
      test_addKey();

      debugMessage("loop() testing key removal");
      test_removeKey();
      executedOnce = true;
    }
  }
  
  processButtonCase();

}

void processButtonCase() {
  heartBeat();

  checkButton();

  if (addKeyMode) {
    addKey("1234");
    addKey("5678");
    addKey("91011");
    addKey("121314");
    addKey("151617");
    addKeyMode = false;
  }
}

unsigned long nextHeartBeat = 0;
void heartBeat() {
  if (millis() > nextHeartBeat) {
    debugMessage("Heartbeat!");
    parpadear (2, 200);
    nextHeartBeat = millis() + 2000;
  }
}

/******************************
   INTERACTION LAYER
 ******************************/

bool didResetMode = false;
void checkButton() {
  if (digitalRead(buttonPin) == LOW) {
    debugMessage("checkButton() Button is low!");
    long lowDetectionMillis = millis();

    while (digitalRead(buttonPin) == LOW) {
      long timeInLow = millis() - lowDetectionMillis;
      if (timeInLow > 3000) {
        debugMessage("checkButton() button was low for more than 3 seconds! Initializing File...");
        initFile();
        didResetMode = true;
        break;
      }
    }
    if (!didResetMode) {
      debugMessage("checkButton() Switching to addKey mode...");
      addKeyMode = true;
    }

    didResetMode = false;
  }
}

/*****************************
   DEBUG LAYER
 *****************************/
void test_addKey() {
  debugMessage("test_addKey() BEGIN!");
  String newKey = "2097876";
  debugMessage("test_addKey() Key to add: " + newKey);

  bool newKeyAlreadyFound = findKey(newKey);
  if (newKeyAlreadyFound) {
    debugMessage("test_addKey() WRONG: Key was not expected, but found. " + newKey);
  } else {
    debugMessage("test_addKey() CORRECT: New Key was not found, as expected. " + newKey);
  }

  debugMessage("test_addKey() Calling addKey()!");
  addKey(newKey);

  debugMessage("test_addKey() verifying addKey() results...");
  bool newKeyFound = findKey(newKey);
  if (newKeyFound) {
    debugMessage("test_addKey() CORRECT: New Key was found as expected. " + newKey);
  } else {
    debugMessage("test_addKey() WRONG: New Key was not found. " + newKey);
  }
}

void test_removeKey() {
  debugMessage("test_removeKey() BEGIN!");
  String keyToRemove = "2097876";
  debugMessage("test_removeKey() Key to remove: " + keyToRemove);

  bool keyToRemovePresent = findKey(keyToRemove);
  if (keyToRemovePresent) {
    debugMessage("test_removeKey() CORRECT: Key to remove is present as expected. " + keyToRemove);
  } else {
    debugMessage("test_removeKey() WRONG: Key to remove is not found!!!. " + keyToRemove);
  }

  debugMessage("test_removeKey() calling remove key...");
  removeKey(keyToRemove);

  if (findKey(keyToRemove)) {
    debugMessage("test_removeKey() WRONG: Key to remove is present. NOT EXPECTED!!!! " + keyToRemove);
  } else {
    debugMessage("test_removeKey() CORRECT: Key to remove not present as expected.");
  }

}
void parpadear(int times, int milliseconds) {
  for (int i = 0; i < times; i++) {
    digitalWrite(ledPin, HIGH);
    delay(milliseconds);
    digitalWrite(ledPin, LOW);
    delay(milliseconds);
  }
}

void debugMessageNoLF(String message) {
  Serial.print (message);
}

void debugMessage(String message) {
  long curMillis = millis();
  Serial.print (curMillis);
  Serial.print (": ");
  Serial.println (message);
}

bool verifyBegin(String fileContent) {
  debugMessage("verifyBegin() BEGIN!");
  if (fileContent.startsWith("FILE_BEGIN_OK")) {
    debugMessage("verifyBegin() CORRECT: File begin is OK");
    return true;
  } else {
    debugMessage("verifyBegin() WRONG: File begin is NOT AS EXPECTED");
    return false;
  }
}
bool verifyEnd(String fileContent) {
  debugMessage("verifyEnd() BEGIN!");
  if (fileContent.endsWith("FILE_END_OK")) {
    debugMessage("verifyEnd() Correct: End of file is as expected");
    return true;
  } else {
    debugMessage("verifyEnd() WRONG: End of file is NOT AS EXPECTED");
    return false;
  }
}

bool verifySize(String fileContent) {
  debugMessage("verifySize() BEGIN!");
  if (fileContent.length() == CONTENT_SIZE) {
    debugMessage("verifySize() CORRECT!");
    return true;
  } else {
    debugMessage("verifySize() WRONG!");
    return false;
  }
}
bool verifySearch() {
  debugMessage("verifySearch() BEGIN!");
  bool k1found = findKey("7598635");
  bool k2found = findKey("notfoundhere");

  if (k1found && ! k2found) {
    debugMessage("verifySearch() SEARCH IS OK!");
    return true;
  } else {
    debugMessage("verifySearch() ERROR!!!! SEARCH IS WRONG!!");
    return false;
  }
}


/******************************************
   BUSINESS LAYER
 ******************************************/

bool findKey(String key) {
  debugMessage("findKey(): " + key);
  String formattedKey = formatKey(key);
  String fileContent = readFile();
  int pos = fileContent.indexOf(formattedKey);
  if (pos > 0) {
    debugMessage("findKey() FOUND: " + key + " at " + String(pos));
    return true;
  } else {
    debugMessage("findKey() Not found: " + key);
    return false;
  }
}

void addKey (String key) {
  debugMessage("AddKey() BEGIN!");
  String fileContent = readFile();
  if (findKey(key) == true) {
    debugMessage("AddKey() Key already stored!");
    return; //Already there
  } else {
    int pos = fileContent.indexOf(",----------");
    String beginning = fileContent.substring(0, pos);
    String thisKey = formatKey(key);
    String restOfFile = fileContent.substring(pos + 11);
    String newFileContent = beginning + thisKey + restOfFile;
    debugMessage("OLD FILE:" + fileContent);
    debugMessage("NEW FILE:" + newFileContent);
    saveFile(newFileContent);
  }
}

String formatKey(String key) {

  int dashesRequired = 10 - key.length();
  String result = "";
  for (int i = 0; i < dashesRequired; i++) {
    result = result + "-";
  }
  return "," + key + result;
}
void removeKey(String key) {
  debugMessage("removeKey() BEGIN!");
  String fileContent = readFile();
  if (findKey(key) == false) {
    debugMessage("removeKey() key not present!");
    return; //Already not there
  } else {
    String formattedKey = formatKey(key);
    debugMessage("removeKey() Formatted Key: |" + formattedKey + "|");
    int pos = fileContent.indexOf(formattedKey);
    debugMessage("removeKey() Index of Formatted key: " + String(pos));
    if (pos > 0) {
      String beginning = fileContent.substring(0, pos);
      String thisKey = formatKey("");
      String restOfFile = fileContent.substring(pos + 11);
      String newFileContent = beginning + thisKey + restOfFile;
      debugMessage("removeKey() OLD FILE:" + fileContent);
      debugMessage("removeKey() NEW FILE:" + newFileContent);
      saveFile(newFileContent);
    } else {
      debugMessage("removeKey() Formatted Key not found! " + formattedKey);
    }
  }

}

/**
   This function initializes file with raw content.
*/
void initFile() {
  debugMessage("initFile() BEGIN!");

  String fileContent = "FILE_BEGIN_OK:123455,7598635---,----------,----------,----------,----------,----------,----------,----------,----------,----------,----------,FILE_END_OK";
  saveFile(fileContent);

  debugMessage("initFile() DONE!");
}


/********************
   DATA ACCESS LAYER
 ********************/

/**
   This function reads file content into an string. Implements full debugging mechanism
*/
String readFile() {
  debugMessage("readFile(): Begin!");

  debugMessage("readFile() Opening file: " + String(filename));
  SerialFlashFile file = SerialFlash.open(filename);

  // Get the size and position
  uint32_t fsize = file.size();
  debugMessage("readFile() Size: " + String(fsize));

  uint32_t filePos = file.position();
  debugMessage("readFile() Position: " + String(filePos));

  debugMessage("readFile() Seeking...");
  file.seek(filePos);

  debugMessage("readFile() Reading buffer...");
  char mybuff[fsize];
  file.read(mybuff, fsize);
  String result = String(mybuff);
  debugMessage("readFile() Closing file...");
  file.close();

  debugMessage("readFile() Content:");
  debugMessageNoLF("|||");
  debugMessageNoLF(result);
  debugMessageNoLF("|||");
  debugMessage("Size:" + String(result.length()));

  debugMessage("readFile() DONE!");
  return result;
}

/**
   This function drops existing file and saves a new one with proposed content.
*/
void saveFile(String newFileContent) {
  debugMessage("saveFile() BEGIN!");

  removeFile();

  uint8_t flashBuffer[CONTENT_SIZE + 1];
  newFileContent.getBytes(flashBuffer, CONTENT_SIZE + 1);
  SerialFlashFile file;


  debugMessage("saveFile() Creating file if not exist...");
  // Create the file if it doesn't exist
  while (!create_if_not_exists(filename)) {
    debugMessage("Memory filled up! Clearing Flash...");
    SerialFlash.eraseAll();

    while (SerialFlash.ready() == false) {
      // wait, 30 seconds to 2 minutes for most chips
    }
  }

  debugMessage("saveFile() Opening file for write!");
  // Open the file and write test data
  file = SerialFlash.open(filename);

  debugMessage("saveFile() Writing into file...!");
  file.write(flashBuffer, CONTENT_SIZE + 1 );
  debugMessage("saveFile() String \"" + String(newFileContent) + "\" written to file " + String(filename));

  debugMessage("saveFile() Closing file...");

  file.close();

  debugMessage("saveFile() DONE!");

}

/**
   This function drops the file.
*/
void removeFile() {
  debugMessage("removeFile() BEGIN!");

  if (SerialFlash.exists(filename)) {
    debugMessage("removeFile() Removing file...");
    SerialFlash.remove(filename);
  } else {
    debugMessage("removeFile() No file to remove..." + String(filename));
  }
  parpadear (3, 50);

  debugMessage("removeFile() DONE!");
}

bool create_if_not_exists (const char *filename) {
  if (!SerialFlash.exists(filename)) {
    debugMessage("Creating file " + String(filename));
    return SerialFlash.create(filename, FSIZE);
  }

  debugMessage("File " + String(filename) + " already exists");
  return true;
}

Comandos por BLE – (Parte 1 de 2) – El Receptor

21 Jul , 2017,
Jose Nunez
, ,
No Comments

Para continuar la exploración de la tecnología BLE que comenzó nuestra compañera Rebeca Rodriguez Tencio acá, les presentamos este primer tutorial de dos relacionados. La idea es poder implementar una forma de enviar comandos a una tarjeta de prototipado via Bluetooth Low Energy (BLE) desde una App de un teléfono Móvil.

En esta primera parte implementaremos un servicio “Comando LED” en un microcontrolador compatible con Arduino 101 llamado TinyTILE (basado en el chip Curie de Intel)

En la segunda parte, implementaremos una App (Android y IOS) usando IONIC 3 que le envía comandos al micro-controlador mediante el sistema BLE del teléfono.

(!) Antes de seguir estas instrucciones asegúrese de entender las Condiciones de Uso de nuestro sitio.

Primero: Programemos el Curie

En resumen:

  1. Necesitaremos un protoboard, un LED, una resistencia de 150 Ohm, un TinyTILE y un cable USB a micro-USB y una PC
  2. El circuito es muy sencillo:


  3. En la PC instalamos los controladores de placa “Arduino/Genuino 101” en el IDE de ARDUINO (V.1.8.2)
    • Menu: Tools >  Board > Board Manager > Search “Curie” > Instalar V 2.0.2 o superior.
  4. Descargamos el programa (sketch) de ejemplo de mi repositorio de Github y lo abrimos con el IDE de ARDUINO.
  5. Instalamos el boceto de ejemplo en la placa
    • Menu: Sketch > Upload
  6. Usamos una app para pruebas BLE denominada “BLE Scanner” para enviar comandos “ON” y “OFF”
  7. Nótese que hemos implementado una función “parpadear” que nos permite ver si el sketch arrancó adecuadamente.

Las siguientes imágenes ilustran el uso de BLE Scanner para enviar los comandos.

Seguidamente mostramos el código original del programa con los comentarios detallados sobre su funcionamiento. Es realmente sencillo; podemos resumirlo en:

  1. Definir un servicio BLE “ServicioBLE_Comando” (línea 5)
  2. Deinir una característica BLE “CaracteristiciaBLE_Comando” de tipo genérica, de lectura y escritura con mensajes de 20 bytes (línea 8)
  3. Darle un nombre al dispositivo “COMANDO LED” e inicializarlo, agregando el servicio y la característica (línea 19)
  4. Publicitamos el servicio (línea 23)
  5. Leemos eventos BLE en la característica (nuevos comandos) que luego son interpretados y ejecutados (líneas 31,33,57,61)
  6. Para esto convertimos el valor recibido a un String (línea 63)

 


#include <CurieBLE.h>
#define ledPin 13

//Definimos un servicio BLE
BLEService servicioBLE_Comandos("db938b80-f010-44b6-8aa9-1835adf9419a"); // create service

//Definimos una característica que pueda ser leida o escrita desde una central BLE, con capacidad de 20 bytes por mensaje.
BLECharacteristic caracteristicaBLE_Comandos("9906064e-9bbe-4eba-b415-bbd223f7d3d9", BLERead | BLEWrite, 20);

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT); 
  delay(500); //Esperamos un poco de tiempo (500ms) por si se puede habilitar la terminal serial.
  parpadear(5,200);//Señalizamos con el LED que estamos iniciando el sketch
  
  BLE.begin(); //Inicializamos el sistema Bluetooth Low Energy (BLE) del Curie
  parpadear(2 ,100);//Señal de aviso de que la operación anterior fue exitosa
  
  BLE.setLocalName("COMANDO LED"); //Definimos un nombre para publicitar nuestro dispositivo
  BLE.setAdvertisedService(servicioBLE_Comandos);//Definimos el servicio que se va a publicitar
  servicioBLE_Comandos.addCharacteristic(caracteristicaBLE_Comandos); //Agregamos la característica al servicio
  BLE.addService(servicioBLE_Comandos); //Agregamos el servicio al dispositivo  
  BLE.advertise(); // Publicitamos el dispositivo
  parpadear(3 ,100);//Señal de aviso de que la operación anterior fue exitosa

  Serial.println("En este punto el dispositivo queda listo, publicitado y esperando conexiones...");
  parpadear(10,50);//Señal de aviso de que SETUP se concluyó satisfactoriamente
}

void loop() {
  BLE.poll(); // Obtenemos cualquier evento BLE que haya sido enviado al dispositivo

  if (caracteristicaBLE_Comandos.written()) { //Si hay datos, ejecutamos el comando
    leerYEjecutarComado();
  } // ... caso contrario simplemente se termina el flujo de loop()
}

/**
 * Este método lee el comando registrado en la característica BLE y lo ejecuta.
 */
void leerYEjecutarComado(){
    String valorDelComando = obtenerValorDelComando();

    if (valorDelComando.startsWith("ON")) {
      Serial.println("LED on");
      digitalWrite(ledPin, HIGH);
    } else {
      Serial.println("LED off");
      digitalWrite(ledPin, LOW);
    }
}

/**
 * Extraer el valor del comando en formato String
 */
String obtenerValorDelComando(){
    int longitudDelComando = caracteristicaBLE_Comandos.valueLength();
    Serial.print("Longitud: ");
    Serial.println(longitudDelComando);
      
    const byte* val = caracteristicaBLE_Comandos.value();
    
    String strValor = String((const char *)val).substring(0, longitudDelComando);
    Serial.println("|" + strValor + "|");

    return strValor;
}

void parpadear(int times, int milliseconds){
  for(int i=0; i<times; i++){
    digitalWrite(ledPin, HIGH);
    delay(milliseconds);
    digitalWrite(ledPin, LOW);
    delay(milliseconds);
  }
}

 

 

Soporte del Intel Realsense para Ubuntu

19 Jun , 2017,
Luis Ramirez
No Comments

http://reconstructme.net/wp-content/uploads/2015/11/r200.jpg

¿Realsense? ¿Que tiene de especial esta cámara?

Pués, la cámara Intel Realsense R200 posee 3 cámaras, las cuales en conjunto con sensores integrados permite generar ambientes en 3 Dimensiones hasta distancias de 5 a 10 metros. 1 cámara brinda imágenes RGB, y las otras 2 brindan imágenes infrarrojas (IR) para reproducir la profundidad. Hace uso de un proyector láser para realizar un escaneo de 3D para percepción de escenas y fotografías mejoradas.

Al permitir hacer escaneo en 3D de habitaciones puede detectar movimientos de manos, cabezas, cuerpos y mucho más.

¡Y algo muy importante! ¡Se puede utilizar con el Intel Joule!https://communities.intel.com/community/image/2729/2.png?a=97855

¿Cómo instalar el soporte para sistemas basados en Linux, como Ubuntu?

 

Primero debemos de asegurarnos que el sistema se encuentra actualizado a la última versión.

sudo apt-get update && sudo apt-get upgrade && sudo apt-get dist-upgrade

Lo segundo es verificar la versión del Kernel de Linux que estamos utilizando

uname -r

El valor que nos imprime debe ser mayor o igual que 4.4.0-50

Luego debemos de instalar algunas dependencias para Librealsense

sudo apt-get install libusb-1.0-0-dev pkg-config

sudo apt-get install libglfw3-dev

 

Posteriormente ocupamos clonar el siguiente repositorio, se puede descargar por medio de la interfaz web en https://github.com/IntelRealSense/librealsense o con el siguiente comando

git clone https://github.com/IntelRealSense/librealsense

Una vez clonado el repositorio nos dirigimos al directorio y ejecutamos el los siguientes comandos

mkdir build && cd build

cmake ../ -DBUILD_EXAMPLES=true

La bandera “DBUILD_EXAMPLES” es para que se compilen los ejemplos con los que podemos probar el funcionamiento de la cámara. El último comando puede tomar bastante tiempo, una vez finalizado ejecutamos lo siguiente

make && sudo make install

Una vez concluido el paso anterior la biblioteca se encontrará instalada en /usr/local/lib y los encabezados se ubican en /usr/local/include Además como compilamos los ejemplos los vamos a poder encontrar en /usr/local/bin

 

https://www.intel.es/content/dam/www/public/us/en/images/photography-abstract/realsense-static-promo-rwd.png.rendition.intel.web.416.234.png

Via Rápida a la Visión Computarizada con SimpleCV

1 Mar , 2017,
Jose Nunez
No Comments

En nuestro tiempo, el campo de la computación visual sigue siendo un área prácticamente inexplorada.

Esta semana hemos comenzado a estudiar una librería que promete ser un empujón de calidad para cualquiera que esté aprendiendo sobre computación visual. Nos referimos a la librería SimpleCV, que abstrae de manera magistral una serie de métodos importantes de la famosa librería OpenCV, haciendo nuestra entrada al mundo de la visión computrizada tan sencillo como decir “Hola Mundo”

Acá les dejo el enlace. Estoy seguro de que no se van a arrepentir:

http://simplecv.org

No olviden compartir en el área de comentarios sus resultados, pruebas, impesiones de SimpleCV

 

–jn

Más material para IoT: El FONA 808 de Adafruit

3 Jun , 2016,
Jose Nunez
No Comments

En esta ocasión estaremos evaluando el FONA 808 de Adafruit; un dispositivo verdaderamente completo para realizar comunicaciones en redes 3G, GSM, GPRS que además trae radio FM y Receptor GPS. Todo por menos de $55.

Dentro de las principales aplicaciones para este dispositivo tenemos la implementación de sistemas de seguimiento de vehículos por GPS con información enviada por internet (monitoreo de flotillas o sistemas para recuperación de vehículo robado) y la creación de tu propio celular.

La lista completa de especificaciones e instrucciones se puede encontrar acá: https://www.adafruit.com/product/2542

Dentro de lo que más nos llamó la atención podemos destacar:

  • GSM de cuatro bandas 850/900/1800/1900MHz para conectarse con prácticamente cuaquier proveedor de red GSM (el ICE por ejemplo)
  • Receptor GPS completamente integrado que puede ser controlado y leido a través de un único puerto serial (Chipset MT3337 con una sensibilidad de seguimiento de -165 dBm)
  • Capacidad de realizar llamadas de voz usando un manos-libres o un parlante de 32Ω  con micrófono electret
  • Capacidad de envío y recepción de mensajería SMS
  • Envío y recepción de datos GPRS (TCP/IP, HTTP, etc) (ESTA ES LA PARTE IOT!)
  • Control de motor de vibración / buzzer PWM
  • Interfaz de comandos “AT” con detección automática de bandasy comandos AT para los módulos GPRS y GPS también. (ver manual de referencia acá para SIM808 y acá para el GPS)
  • Biblioteca para ARDUINO IDE bastante estable y completa (Arduino FONA Library by Adafruit Version 1.3.2) con ejemplos de las diferentes funciones del dispositivo. Puede obtenerse directamente desde el administrador de librerías de ARDUINO IDE o desde github

Referencias

Este tutorial está basado en el tutorial de Adafruit publicado aca: https://learn.adafruit.com/adafruit-fona-808-cellular-plus-gps-breakout

Aviso de Responsabilidad Limitada

(!) Antes de seguir estas instrucciones asegúrese de entender las Condiciones de Uso de nuestro sitio.

Experimento Básico

Este experiento toma menos de una hora si ya tienes todos los materiales a mano. Consiste en instalar la biblioteca ARDUINO FONA en el ARDUINO IDE 1.6.8 y ejecutar algunas pruebas con el sketch de ejemplo llamado “FONATest”


MATERIALES: ($120)

  • 1x ARDUINO UNO ($25)
  • 1x Adafruit FONA808 ($55)
  • 1x Cable USB para programar el ARDUINO ($9)
  • 1x Batería LIPO standard de 3.7V con conector JST ($19)
  • 1x Antena Pasiva de GPS ($6)
  • 1x Antena GPRS ($4)
  • 1x Tarjeta SIM 3g/GSM (~$2)
  • 1x Computador con puertos USB disponible y sistema operativo Windows (puede ser LINUX o OSX, pero este procedimiento lo realizamos con Windows 8.1)

RESUMEN

  • PASO 1: Conecte los componentes e instale una tarjeta SIM (en nuestro caso usamos una tarjeta SIM del proveedor Kolbi del I.C.E. de Costa Rica, de un servicio MIFI que habíamos contratado de previo)
  • PASO 2: Instale la biblioteca Arduino FONA Library by Adafruit Version 1.3.2 usando la opción de menú “Manage Libraries” (Menu>Sketch>Include Library>Manage Libraries)
  • PASO 3: Modifique la biblioteca para reemplazar el APN de FONAnet al APN de su proveedor de red (kolbi3g en nuestro caso)
  • PASO 4: Abra el ejemplo “FONA Test”
    Menu>File>Exampels>Adafruit FONA Library>FONAtest
  • PASO 5: Ejecute pruebas:
    1. Encender GPS
    2. Leer Ubicación GPS
    3. Encender GPRS
    4. Leer Ubicación GPRS

PASOS Detallados:

PASO 1 – Conexiones Eléctricas

adafruit_products_2542_iso_demo_SIZED

Aparte de conectar la batería y las antenas, el FONA808 trae una hilera de pines para ser soldados.

Los pines se describen (en inglés) con mayor detalle en este enlace: https://learn.adafruit.com/adafruit-fona-808-cellular-plus-gps-breakout/pinouts

En este otro enlace también se ilustra el procedimiento para soldar los pines y para insertar la tarjeta SIM. (!) Es importante destacar que el pin VIO y el pin KEY son sumamente importantes para poder encender el FONA 808. El pin VIO determina el voltaje de referencia de las entradas y salidas. Para un ARDUINO UNO debe ser 5V, pero hay otros controladores que funcionan con 3.3V. El pin KEY se pone a tierra (GND) para que el dispositivo permanezca encendido. Se puede dejar suelto, pero habría que presionar el botón KEY del dispositivo para encenderlo.

Edición 2017-03-02: Es indispensable contar con la batería LIPO 3.3V. Sin esta batería el módulo no funciona.

También, aquí se detalla en inglés el procedimiento para conectar el dispositivo a una tarjeta ARDUINO. Estas conexiones se listan seguidamente:

  • FONA VIO ==> ARDUINO 5V      (Rojo)
  • FONA GND ==> ARDUINO GND     (Negro)
  • FONA KEY ==> ARDUINO GND     (Café)
  • FONA RX  ==> ARDUINO 2 (TX)  (Amarillo)
  • FONA TX  ==> ARDUINO 3 (RX)  (Naranja)
  • FONA RTS ==> ARDUINO 4 (D4) (Verde) (*) No confunfir el pin RTS del FONA 808 con el RST. RTS se encuentra justo entre KEY y TX

IMG_20160603_125613

PASO 2 – Instale la biblioteca “Arduino FONA Library by Adafruit Version 1.3.2”

Usando la opción de Menú “Manage Libraries” (Menu>Sketch>Include Library>Manage Libraries) Busque e instale la biblioteca “Arduino FONA Library by Adafruit Version 1.3.2”

Capture     Capture3

PASO 3 – Modifique la biblioteca para usar el APN adecuado

Aparentemente por error, la librería trae “hard-coded” el nombre del Access Point Name (APN) para la red GPRS apuntando a “FONAnet” esto hace que las pruebas para la red GPRS no funcionen. Para solventar este problema, consiga el APN de su proveedor de red (en mi caso kolbi3g es el que usamos para la red celular del ICE)

  • Abra el archivo de la librería Adafruit_FONA.cpp ubicado normalmente en la siguiente carpeta de su sistema Windows:
    C:\Users\usuario\Documents\Arduino\libraries\Adafruit_FONA_Library/
  • (!) Para habilitar el GPRS: modifique la línea apn = F("FONAnet"); (línea 28) con la línea  apn = F("kolbi3g");

PASO 4 – Use el programa (sketch) de ejemplo FONA TEST

Abra el programa de ejemplo FONAtest desde el menú (Menu>File>Exampels>Adafruit FONA Library>FONAtest) y súbalo a su ARDUINO UNO.

Una vez que haya terminado de subir el programa, abra el monitor de puerto serial [SHIFT] + [CTRL] + [M]

Asegúrese de que la configuración de velocidad e interpretación del Monitor Serial sean las adecuadas.

adafruit_products_checkbaud

PASO 5 – Pruebas Específicas

El monitor de puerto serial mostrará un Menú y recibirá comandos desde la caja de texto que se encuentra en la parte superior de la pantalla.

Digite “?” y [ENTER] para mostrar el menú de opciones. El menú disponible varia para las diferentes versiones del dispositivo. En nuestro caso tenemos el FONA 808 V2.

Digite “O” y [ENTER] para encender el GPS

Digite “L” y [ENTER] para leer la posición del GPS. Nótese que el formato consiste en una serie de valores separados por comas. El 2do valor es un 0 (cero) cuando el dispositivo aun no se ha conectado a suficientes satélites para identificar su ubicación global, y 1 (uno) cuando si está conectado.

Digite “o” y [ENTER] para apagar el GPS.

Digite “G” y [ENTER] para activar el sistema GPRS. Esto permite la comunicación por internet y el sistema de posicionamiento basado en antenas de la red celular.

Digite “l” y [ENTER] para consultar la ubicación de acuerdo con el sistema GPRS. Es un sistema alternativo al GPS, muchas veces de menor precisión pero de más fácil “adquisición”.

Servo-motores y Resolución Angular

22 May , 2016,
Jose Nunez
No Comments

Recientemente estuve jugando con unos servos para un proyecto que requiere hacer que el servo se mueva “grado por grado” desde cero hasta 180 grados.

Descubrí que de los 0º a los 10° no parece ocurrir movimiento alguno, así que por accidente descubrí que los servos comerciales que compré no tienen una resolución menor a 10 grados.

El siguiente sketch de Arduino hace ese barrido desde los  0º a los 180° en cámara lenta, de forma que nos permite ver de manera experimental cual es la resolución de un servo determinado.

En mi caso, al parecer el servo que tengo tiene una resolución de aproximadamente 7°, lo que quiere decir que si le pido una posición que no dista más de 7 grados de la posición actual, el servo no se moverá.


#include  
#include "rgb_lcd.h"
#define trigger    2
#define echo       7
#define led       13
rgb_lcd lcd;
Servo myservo;  // create servo object to control a servo 
                // a maximum of eight servo objects can be created 
 

void setup() 
{ 
  Serial.begin(9600);
  Serial.println("SETUP");
  lcd.begin(16,2); // columns, rows.  use 16,2 for a 16x2 LCD, etc.
  lcd.setRGB(50,50,50);
  pinMode(trigger, OUTPUT);
  pinMode(echo, INPUT);
  pinMode(13,OUTPUT);
  myservo.attach(3);  // attaches the servo on pin 9 to the servo object 
  myservo.write(0);
  Serial.println("SETUP COMPLETE!");
} 
 
 
void loop() 
{ 
  Serial.println("BEGINING SCAN...");
  blinkEffect(3,500);
  Serial.println("SCANNING...");
  for(int i=0; i<=180; i++){
    Serial.print("ANGLE: ");
    Serial.println(i);
    lcd.setCursor(0,0);
    lcd.print("ANGLE: ");
    lcd.print(i);
    lcd.print("    ");
    myservo.write(i);
    delay(1000);
  }
} 


void blinkEffect(int times, int duration){
  for(int i=0; i<3; i++){
    digitalWrite(led,HIGH);
    delay(duration);
    digitalWrite(led,LOW);
    delay(duration);
  }
}