FONA808 + ARDUINO UNO – FASE 1: Conexión, Comandos AT y Mensajes SMS

En este tutorial demostramos cómo conectar un modem FONA 808 de  Adafruit con un ARDUINO UNO para poder realizar operaciones en la red de telefonía movil GSM tales como el envío de mensajes SMS o comunicación por internet usando una red 3G.

En esta entrega discutiremos las conexiones de diversos puertos y pines del FONA, así como el envío de comandos AT mediante el monitor serial del IDE de ARDUINO (o cualquier terminal serial conectada al ARDUINO) Continuar leyendo “FONA808 + ARDUINO UNO – FASE 1: Conexión, Comandos AT y Mensajes SMS”

RFID Usando RDM6300 y Arduino 101, TinyTILE o ARDUINO UNO

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

El RDM6300 es un módulo bastante sencillo de utilizar en el entorno de ARDUINO gracias a la librería RDM6300 que se puede descargar de acá.

El módulo tiene tres conectores:

P1 (6 contactos): que contiene los pines para realizar comunicaciones. En este experimento utilizaremos solamente el pin 1 ubicado en la esquina que lo conectaremos al pin 6 del Arduino 101. Básicamente este es el único pin que se conecta al microcontrolador.

P2 (2 contactos) que es donde se conecta la antena (bobina)

P3 (3 contactos) que es donde se alimenta el sistema y donde se pude agregar un LED (todavía no tengo claro para qué exactamente) el punto es que de este solo utilizaremos el pin 2 y 3 que son +5V  y GND respectivamente.

El programa que utilizamos simula la apertura de un sistema mediante un pulso a un LED verde conectado al pin 3 de Arduino, y un pulso para cerrar simulado por un LED amarillo conectado al pin 2 del Arduino.

Algo interesante es que el Arduino 101 opera a 3.3V pero es tolerante a señales de 5V lo cual lo hace particularmente versatil (esto también aplica para TinyTILE. Con Arduino UNO también funciona.

Conexiones:

ARDUINO
PIN  2 ==> amarillo ====> LED Amarillo ===> Resistencia 150 Ohm ==> GND
PIN  3 ==> verde =======> LED Verde ======> Resistencia 150 Ohm ==> GND
PIN  6 <== café <======== PIN 1 del conector P1 del RDM6300 (TX)
PIN 13 ==> naranja =====> LED Verde ======> Resistencia 150 Ohm ==> GND
5V ======> rojo ========> Puerto + del protoboard
GND =====> negro =======> Puerto - del protoboard

RDM6300
PIN 2 del conector P3 (Vin) <===== Puerto + del protoboard (operando a 5V)
PIN 3 del conector P3 (GND) <===== Puerto - del protoboard

PIN 1 del conector P1 (TX) ======> PIN 6 del ARDUINO

Conector P2 =====< ANTENA (bobina)

 

Programa de ejemplo:

La versión oficial de este sketch se puede encontrar acá: https://github.com/janunezc/robotics/tree/master/rfid/rfid_rdm630_open_then_close

(!) También, será necesario que los archivos de la librería RDM6300 estén disponibles para compilar el sketch. Se puede copiar ambos archivos (rdm630.h y rdm630.cpp) en la misma carpeta del sketch, o en la carpeta de librerías del ARDUINO IDE (c:\user\myusername\documents\Arduino\libraries\rdm630\***). Es importante asegurarse que la librería RDM630 solo está copiada una vez en las diferentes rutas.

/*
 * Programa escrito por Jose Nunez como ejemplo didáctico del uso del RDM6300 con un ARDUINO 101.
 * Use bajo su propio riesgo.
 * Ejemplo de dominio público.
 *
*/
#include "rdm630.h"

rdm630 rfid(6, 0);  //TX-pin of RDM630 connected to Arduino pin 6
int led_yellow_close = 2;
int led_green_open = 3;
int led_signal = 13;
long OPEN_PULSE_WIDTH = 800;
long CLOSE_PULSE_WIDTH = 1000;
long OPEN_STATE_DURATION = 5000; 
long CODE_READ_DELAY = 10000;
long codeReadDelayMaxMillis = millis();

void setup()
{
    Serial.begin(115200);  // start serial to PC
    pinMode(led_yellow_close, OUTPUT);
    pinMode(led_green_open, OUTPUT);
    pinMode(led_signal, OUTPUT);
    rfid.begin();
    ledSignal(5,500);
    setMessage("READY!");
}

void loop()
{
  unsigned long rfidTagCode = 0;  
  
  if(rfid.available()){
    setMessage("RFID Data is available! reading it...");
    rfidTagCode = readRFIDCode();
    setMessage("Data: " + String(rfidTagCode));
    if(millis() > codeReadDelayMaxMillis) {
      if(rfidTagCode == 7598635) {
        setMessage("OPEN");
        openPulse();//This involves a closePulse() call inside the openPulse() function.
        codeReadDelayMaxMillis = millis() + CODE_READ_DELAY;
      } else {
        setMessage("I DONT KNOW YOU!");
        closePulse();
      }
    } else {
      setMessage("SkippingNewReads");
      delay(500);
    }   
  }
}

void openPulse(){
  setMessage("SENDING OPEN PULSE");
  digitalWrite(led_green_open, HIGH);
  delay(OPEN_PULSE_WIDTH);
  digitalWrite(led_green_open,LOW);
  setMessage("OPEN PULSE DONE! Waiting for OPEN STATE DURATION...");
  delay(OPEN_STATE_DURATION);
  setMessage("OPEN STATE COMPLETE");
  closePulse();
}

void closePulse(){
  setMessage("SENDING CLOSE PULSE");
  digitalWrite(led_yellow_close, HIGH);
  delay(CLOSE_PULSE_WIDTH);
  digitalWrite(led_yellow_close, LOW);
  setMessage("CLOSE PULSE DONE!");
}

unsigned long readRFIDCode(){
  byte data[6];
  byte length;

  rfid.getData(data,length);
  Serial.println("Data valid");
  for(int i=0;i<length;i++){
      Serial.print(data[i],HEX);
      Serial.print(" ");
  }
  Serial.println();
  //concatenate the bytes in the data array to one long which can be 
  //rendered as a decimal number
  unsigned long result = 
    ((unsigned long int)data[1]<<24) + 
    ((unsigned long int)data[2]<<16) + 
    ((unsigned long int)data[3]<<8) + 
    data[4];              
  Serial.print("decimal CardID: ");
  Serial.println(result);
  return result;  
}

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

void addToMessage(String message){
  setMessage(message, false);
}

void setMessage(String message){
  setMessage(message, true);
}

void setMessage(String message, bool newLine){
  String timeStamp = String(millis());
  String finalMessage = timeStamp + " - " + message;
  if(newLine){
    Serial.println(finalMessage);
  } else {
    Serial.print(message);
  }
}

Acá un ejemplo de la ejecución:

Espero que les sea de utilidad.

Comenzando con Intel Galileo

IMG_20161206_202348Tomando en cuenta una pequeña comunidad que hay acá en C.R. sobre Intel Galileo GEN2, acá les presentamos un pequeño resumen introductorio.

La línea Galileo de Intel parece estar más orientada a la parte didáctica de microcontroladores que funcionan con ARDUINO mezclada con Micro-computadores que corren LINUX.

Enlace con Especificaciones

Para “iniciar” con este dispositivo no se necesita mayor cosa, solo un cable de tipo USB-a-microUSB (~$6) para programarlo mediante el ambiente ARDUINO IDE. Es el mismo tipo de cable que se usa para cargar una mayoría de teléfonos Android desde una PC.

Hay un tutorial en Inglés acá: https://software.intel.com/en-us/get-started-galileo-windows

Para sacarle mayor provecho se recomienda tener lo siguiente:
• Tarjeta Micro SD de 2GB a 32GB (crcibernetica ~$8) Para instalar una versión LINUX personalizada
• Cable de tipo “6-pin Serial to Type A USB cable (FTDI cable # TTL-232R-3V3 is recommended ($20 en Amazon)” o interfaz USB/SERIAL/FTDI tipo FOCA 2.2 ($ 11 en crcibernetica) Para acceder a la consola LINUX
• Tarjeta WiFi para laptop (Centrino N135 o Centrino 6205 ~$11-$14 en Amazon) para darle conectividad WiFi. Ambas tarjetas requieren este accesorio.

La presentación estándar de Intel Galileo GEN2 incluye la fuente de poder.

El dispositivo puede ser programado con ARDUINO IDE o mediante la plataforma LINUX que corre.

Comunicación Inalámbrica usando dos NRF24L01 de bajo costo

Descripción

En este tutorial utilizaremos la librería denominada “RF24 by TMRh20” v.1.1.6 para ARDUINO IDE para comunicar dos dispositivos NRF24, uno como transmisor y otro como receptor, conectados a placas ARDUINO UNO y INTEL EDISON respectivamente.

Vamos a monitorear el resultado mediante los puertos seriales respectivos.

NIVEL INTERMEDIO

Referencias Externas

Un agradecimiento especial a terry@yourduino.com por su tutorial sobre los diferentes tipos de conexion para las multiples librerias disponibles para el NRF24.

Materiales

(*) Opcionalmente el Edison se puede reemplazar con otra tarjeta ARDUINO UNO

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

Pre-requisitos

  1. Realice la configuración previa del Intel Edison (controladores, firmware, software en general) para su PC. Existen varios tutoriales para esto. Por ejemplo este.
  2. Instale el IDE de ARDUINO de https://www.arduino.cc/en/Main/Software
  3. Instale la librería “RF24 by TMRh20” en el ARDUINO IDE (Menu: Sketch > Include Library > Manage Libraries > [Install] )

rf24 manage libraries

Figura 1 – Librería RF24 by TMRh20

 

Pasos Resumidos

  1. Conecte los módulos nRF24 a las placas EDISON y ARDUINO tal y como se describe en la figura 2 abajo.
  2. Abra el ejemplo “RF24 > Getting Started” y programe con él su tarjeta ARDUINO (transmisor)
  3. Modifique el programa de ejemplo para que la variable “radioNumber” tenga un valor de 1 (ver figura 5) y programe su tarjeta EDISON (receptor) con este programa modificado.
  4. Monitoree el transmisor usando una conexion serial (Serial Monitor del ARDUINO IDE o PuTTY a 115200 baudios) y presione la tecla “T”

Procedimiento Detallado

PASO 1 –  CONEXIONES

La siguiente imagen ilustra las conexiones desde los pines del NRF24 a las placas ARDUINO o EDISON.

nrf24 pin connections

Figura 2 – Conexiones


PASO 2 – PROGRAMANDO EL TRANSMISOR

Abra el ejemplo de la librería “RF24 by TMRh20” denominado “Getting Started” (Menu: File > Examples > RF24 > Getting Started)

La variable “radio Number” definida en la línea 14 determina el modo de operación, en este caso debe ser 0 (tal y como viene predeterminada) para el transmisor.

radionumber_0

Figura 3 – Variable Radio Number para Transmisor

Cargue el programa en su tarjeta ARDUINO.

El monitor serial del IDE de arduino debe estar configurado para operar a 115200 baudios (ver figura 4).

(!) En este punto la tarjeta ARDUINO estará lista para transmitir; esperando que se conecte un receptor a la red. Puede apagar el ARDUINO por el momento.

115200

Figura 4 – Configuración de la pantalla de monitor serial


PASO 3 – PROGRAMANDO EL RECEPTOR

Utilizando el mismo programa, modifique el valor de la variable “radioNumber” para que sea igual a 1 (ver figura 5) y programe su tarjeta EDISON con esta nueva versión del programa.

radionumber_1

Figura 5 – radioNumber = 1

(!) En este punto la tarjeta EDISON estará lista para recibir datos, esperando mensajes del transmisor. Al abrir el monitor serial (SHIFT + CTRL + M) no se observará ninguna reacción. Recuerde asegurarse de que la velocidad del monitor sea 115200 baudios.


PASO 4 – PRUEBAS FINALES

Encienda el ARDUINO UNO (transmisor) conectándolo a su computador y abra el monitor serial. Verá una imagen similar a la figura 4.

Encienda el EDISON (receptor) conectándolo a la fuente de poder y al computador. Abra una terminal “PuTTY” para ver el monitoreo serial del EDISON. Recuerde la usar el puerto “Intel Virtual COM Port (COM??)” a una velocidad de 115200  como se ilusrta en la figura 6.

PuTTY_VirtualCOMPort

Figura 6 – Configurando PuTTY para monitorear el EDISON

Vaya al Monitor Serial del ARDUINO IDE y presione la tecla T

En este momento veremos como se comunican los dos equipos de manera inalámbrica como se ilustra en la figura 7.

Test_Sending_Receiving

Figura 7 – Monitoreando Transmisor y Receptor

(!) Nótese que aquí utilizamos los términos TRANSMISOR para el ARDUINO UNO y RECEPTOR para el EDISON con cierta ligereza. Ambos dispositivos transmiten y reciben en distintos momentos. El ARDUINO UNO envia datos al EDISON, el cual los envia de vuelta al ARDUINO UNO.