Comunicaciones Bluetooth para Arduino
Comunicaciones Bluetooth para Arduino
INDICE BLUETOOTH
Los modulos Bluetooth
Home
Indice Bluetooth
Tienda Prometec
Baterias
Comprar Arduino
Comprar Comunicaciones
Comprar Motores
Displays
Electronica
Fuentes de Alimentacion
Impresora 3D
LED light
RaspBeryy_PI
Robot
Sensores
Shields
Varios
Productos Populares
Arduino Nano
8.20€ + IVA
Rueda + Motor
6.20€ + IVA
BUSCADOR
submit
Nombre de usuario
Contraseña
Recordarme
Registrarse
Identifícate
Administracion
Comunicaciones
Motores
Proyectos
Sensores y actuadores
Categorías
Admin
arduino
BlueTooth
comunicaciones
ethernet shield
Libros
Referencia C++
Sin categoría
Entradas Recientes
Rotary Encoders
Carrito
Copyright Prometec
Home
Módulo BlueTooth HC-06
OBJETIVOS
MATERIAL REQUERIDO.
ARDUINO MODULO
UNO REV 3 BLUETOOTH
HC-06
Añadir al
carrito Añadir al
carrito
CABLES
DUPONT
MACHO-
HEMBRA
Añadir al
carrito
Pocos de los que estén leyendo estas líneas, no tendrán un teléfono móvil en el bolsillo, y muy probablemente será del tipo Smartphone, que
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
incluirán un sistema operativo como Android o Apple IOS equipados con Wifi y Bluetooth.
Por eso la posibilidad de integrar conexión WIFI o BlueTooth en nuestros proyectos, nos abre unas posibilidades inmensas. Poder controlar nuestros
proyectos desde el propio móvil, bien con WIFI o bien con BlueTooth, es algo muy interesante para controlar montajes de diferentes tipos.
En las sesiones previas, vimos cómo usar el móvil conectado a la red local para gobernar múltiples salidas digitales, y en próximas sesiones veremos
cómo usar el WIFI como sistema de control desde nuestros teléfonos.
Pero como los grandes viajes deben empezar con pequeños pasitos, vamos a dedicar un par de capítulos al BlueTooth, para ver de qué posibilidades
disponemos, como configurarlos y demás. De modo que seamos capaces de integrar el BlueTooth con nuestros Arduinos.
Y para ello empezaremos hablando un poco, de que es el BlueTooth y de cómo funciona, así como unos pocos conceptos básicos claves, para
poderlo usar con garantías de éxito.
Para empezar diremos que los dispositivos BlueTooth pueden actuar como Masters o como Slaves (Amos o esclavos).
La diferencia es que un BlueTooth Slave solo puede conectarse a un master y a nadie más, en cambio un master BlueTooth, puede conectarse a
varios Slaves o permitir que ellos se conecten y recibir y solicitar información de todos ellos, arbitrando las transferencias de información ( Hasta un
máximo de 7 Slaves)
La dirección propia también se puede identificar pero lógicamente, es un poco menos cómoda y tiene menos utilidad. Tampoco es raro establecer un
protocolo IP sobre transporte BlueTooth, con lo que además de su identificación interna BlueTooth (Equivalente al MAC Ethernet) dispondrá de una
dirección IP para conectarse a Internet.
Por eso puedes conectarte vía Bluetooth a tu PC, por ejemplo, y a través de el conectarte a internet.
Así pues un nodo BlueTooth puede ser Master o Slave y dispone de una dirección única, así como de un nombre para identificarse y muy
habitualmente también incluye un PIN de conexión o número de identificación que debe teclearse para ganar acceso al mismo.
Como el BlueTooth lo desarrolló Nokia para conectar teléfonos móviles, a otros dispositivos como auriculares, micrófonos o conexiones al audio del
coche, existe un procedimiento definido que se llama Pairing (o emparejamiento) que vincula a dos dispositivos Bluetooth.
Cuando vinculas dos dispositivos BT, se inicia un proceso en el que ellos se identifican por nombre y dirección interna y se solicitan la clave PIN para
autorizar la conexión.
Si el emparejamiento se realiza con éxito, ambos nodos suelen guardar la identificación del otro y cuando se encuentran cerca se vuelven a vincular
sin necesidad de intervención manual. Por eso el CD de tu coche reconoce el móvil de tu bolsillo en cuanto te subes y puedes reproducir la música
que tienes en tu Smartphone.
Aunque para que tu BlueTooth pueda enviar o recibir música, debe aceptar otra norma posterior llamada
Advanced Audio Distribution Profile (A2DP) y que en caso de ser algún sistema antiguo te impedirá la
reproducción.
Naturalmente, a lo largo de los años la norma ha ido variando y existen varias versiones de la misma, con compatibilidad siempre con las versiones
anteriores que se diferencian en la distancia que pueden alcanzar (entre 50 y 100 metros, teóricamente y sin obstáculos) además de la velocidad de
transferencia.
Hace ya un tiempo que disponemos de módulos BlueTooth sencillos y económicos, que resultan muy prácticos para todo esto, y en esta sesión,
vamos a empezar viendo cuales tenemos disponibles y como trabajar con ellos.
Los más frecuentes en el mercado son los módulos HC-06 y HC-05 que si hacéis una búsqueda por eBay o similares veréis que se consiguen por
poco dinero, y están disponibles independientes o en modo SHIELD y para zocalo XBEE (ya hablaremos).
Hay bastante confusión en la red acerca de cómo diferenciar uno de otro y en muchas ocasiones sobre las prestaciones de unos y otros. Vamos a
ver si podemos aclarar un poco el tema.
Lo primero es que el hardware de ambos modulos es el mismo. No hay diferencia hardware, pero el software que incorporan es diferente
De hecho, parece que es posible reprogramar uno para covertirlo en el otro, aunque el procedimiento es
aparentemente bastante pesado.
Ademas el modulo de conexión se monta sobre un soporte que a su vez puede presentar diferencias notables según el fabricante y las conexiones
que realice, pero por lo que he podido comprobar con un par de modulos de los que dispongo, hay una diferencia obvia, el numero de pines del
modulo montado.
Basicamente el modelo HC-06 solo puede actuar como esclavo y además dispone de un juego reducido de instrucciones a las que atiende, mientras
que el modelo HC-05 puede actuar como master o como Slave y acepta un número mayor de órdenes de configuración.
En esta sesión vamos a usar el modelo HC-06, pero antes necesitamos hablar de la cuestión de los comandos AT.
LOS COMANDOS AT
El interface no era USB sino RS232, que aunque físicamente diferente, comunicaban vía serie dos puntos próximos hasta un máximo, de digamos,
unos 100 metros.
Pero cuando querías enviar información a otro equipo situado en una oficina remota de tu empresa, la única posibilidad era utilizar las líneas
telefónicas, mediante un adaptador diabólico, que se llamaba Modem.
La idea básica, era codificar el 0 binario con un tono grave de audio (que se pudiera enviar por la línea de teléfono) y los unos binarios como un tono
agudo.
Así con la sucesión más o menos rápida de tonos graves y agudos por la línea telefónica se podían enviar un mensaje binario codificado en frecuencia
de audio, de un punto a otro.
La palabra Modem, que tal vez hayáis oído, deriva del apocope de MODulador DEModulador, y si veis pelis
de los años 80 y primeros 90 eran esos chismes que hacían los ruiditos típicos de audio, asociados a la
informática.
Naturalmente, las líneas telefónicas eran analógicas, lo que implicaba una cantidad indecente de ruido térmico, que aumentaba exponencialmente
con la distancia, obligando a disminuir la velocidad en función del ruido que te encontraras y a retransmitir una y otra vez el mensaje hasta que
conseguías que llegara correctamente (algo que rara vez pasaba a la primera)
La velocidad de los módems empezaron sobre los 300 baudios o bits por segundos y fueron aumentando
con la revolución tecnológica hasta 1.200, 2.400, 9.600 y que yo sepa los últimos que se comercializaron
con el ese nombre fueron de 56.000 baudios. (Compara esos 56k de máximo con las redes de cable
modernas de 100 Mbps, casi 1.800 veces más rápidas)
Por eso, los módems necesitaban una especie de comandos, que nos permitiera modificar la velocidad según necesitáramos, léase bajarla, cuando el
ruido impedía una comunicación fiable y ya de paso modificar algún que otro parámetro sobre la marcha.
Es decir que las ordenes eran del tipo “AT+Orden”, donde AT era el comando especificado de atención. En un santiamén todos los módems y demás
máquinas de comunicación serie empezaron a aceptar este tipo de órdenes, y al conjunto de ellas se llamó comandos AT, por extensión.
Con el tiempo, mucho del hardware sencillo que se comunica con otros equipos vía una humilde puerta serie, siguen aceptando ordenes AT para
configurarlos y este es el caso de los módulos BlueTooth HC-05, HC-06 y otros pequeños dispositivos que veremos en el futuro.
Pues es cantidad de fácil. Fíjate que el modulo tiene rotulado el nombre de los pines, y simplemente conectar tensión y GND al módulo y después
conectamos Txd y Rxd a los pines digitales 2 y 4 respectivamente de tu Arduino. Eso es todo
Fijaros que al hacer esta conexión, el LED del módulo HC-06, parpadea continuamente. Esto indica que no está pareado o vinculado.
Cuando conectes algo al módulo, esta luz se quedará fija y es la forma de saber si hay conexión o no.
EL PROGRAMA DE CONTROL
Sin embargo, prefiero desaconsejar hacerlo así, porque los pines 0 y 1 se utilizan en la comunicación serie de Arduino con el PC a través del USB y
por tanto, si los usamos para comunicar con el modulo BT, perderíamos la conexión con el PC.
Por ello prefiero destinar otro par de pines cualesquiera a la transmisión, aunque para ello tenemos que importar una librería que habilite la
comunicación serie con otros pines como es la librería SoftwareSerial .
Para ello importamos la librería que viene de serie en el IDE y creamos un nuevo objeto serie llamado BT1 conectado a los pines 4 y 2:
#include <SoftwareSerial.h>
SoftwareSerial BT1(4,2); // RX, TX
Vamos a escribir un programa para comunicarnos con el modulo BT que simplemente lee lo que se escribe en la puerta BT1 y si hay algo lo manda a
la consola Serial.
A su vez si hay algo en la consola, lee una línea con GetLine() y finaliza con intro antes de enviar la línea completa al BT1
El motivo es, que el modulo HC-06, a diferencia del HC-05, no espera un terminador de línea como \n, si no
que salta por tiempo, lo que nos fuerza a escribir muy deprisa los comandos largos y resulta incómodo..
Si no escribimos el comando completo a tiempo, simplemente lo ignorará y ni siquiera dará error. Por eso
prefiero mandar comandos completos directamente y no carácter a carácter.
void setup()
{
Serial.begin(9600);
Serial.println("Enter AT commands:");
BT1.begin(9600);
}
void loop()
{
if (BT1.available())
Serial.write(BT1.read());
if (Serial.available())
{ String S = GetLine();
BT1.print(S);
Serial.println("---> " + S);
}
}
String GetLine()
{ String S = "" ;
if (Serial.available())
{ char c = Serial.read(); ;
while ( c != '\n') //Hasta que el caracter sea intro
{ S = S + c ;
delay(25) ;
c = Serial.read();
}
return( S + '\n') ;
}
}
BT1.begin(9600);
Si por cualquier motivo, no consigues establecer comunicación con el modulo BT, vete cambiando la velocidad hasta que veas que hay conexión.
Fíjate ahora, en el modulo, verás una luz roja parpadeando. Eso significa que el modulo está listo para vincularse a un dispositivo BlueTooth o para
aceptar comandos AT, el modulo HC-06 no necesita nada mas para entrar en modo de aceptar comandos AT.
De hecho siempre que veas la luz parpadeando significa que el modulo no retransmitirá los comandos AT,
sino que los interpretara como ordenes internas.
Pero si realizas una conexión (y la luz roja se queda fija, ignorará los comandos AT y los transferirá sin más .
Si no te has vinculado aún, y la luz roja parpadea, ya podemos enviar comandos AT. Veamos algún ejemplo.
Con el HC-06 es necesario que en el Monitor Serial seleccionemos “Sin ajuste de línea”.
Si usamos el HC-05, por el contrario, tendremos que seleccionar “Ambos NL & CR”.
El primero y más básico es enviar (siempre en mayúsculas) un simple AT desde la consola. Se supone que debería responder con OK, pero en mi caso
y con mi modulo no es así. Y si vuestro caso es el mismo deberéis probar con más comandos.
AT+NAMEXXX, Programa el nombre que queremos presentar cuando alguien nos busque:
AT+NAMEPROMETEC
AT+BAUDX, Fija la velocidad de comunicación entre el modulo y la consola según a la siguiente tabla:
AT+PINXXXX, configura el número de identificación personal, que se requerirá para establecer la vinculación
En caso de que probando varios de estos comandos, no obtuvierais respuesta, o vierais caracteres extraños en la consola, probad con otras
velocidades hasta conseguir una que funcione. Probad diferentes velocidades en la línea:
BT1.begin(9600);
Y me temo que parece no haber más comandos disponibles para un módulo HC-06 y desde luego no dispone de los comandos de interrogación de
los que si dispones su hermano mayor HC-05.
Para ello voy a utilizar un teléfono Android y un programa Android llamado Bluetooth SPP, pero en realidad servirá cualquier terminal BT.
Debo indicar que no he sido capaz de vincular este módulo a mi Iphone 4S, porque este insiste en que no
existe nada en los alrededores con lo que vincularse y en cambio mi viejo HTC Android 2.1 lo ve a la primera
y sin problemas.
Lo primero es confirmar que el LED del módulo BT parpadea, indicando que está en modo AT o esperando vinculación con otro dispositivo. Después
asegúrate de que el BlueTooth del teléfono está activo y por último, dependiendo del programa que uses como terminal, pídele que busque
dispositivos BT en los alrededores y vincúlate al que encuentres.
Si todo va bien ya podrás enviar y recibir mensajes de texto entre tu móvil y Arduino en ambas direcciones.
Hemos presentado algunos conceptos básicos del mundo Bluettoth y su relación con Arduino.
Vimos lo que son los comandos AT y de donde provienen, asi como algunos de ellos que sirven para
programar el modulo HC-06.
Escribimos un programa básico para comunicar un teléfono Bluetooth con Arduino mediante un
programa de terminal BlueTooth.
(268) Comments
Dicho esto, quisiera hacerte una pregunta que yo mismo llevo haciéndome desde hace tiempo, cuya respuesta no he
podido encontrar, y que es la siguiente: Es posible hacer que arduino reconozca específicamente a un dispositivo
bluetooth al que se conecte (mediante su dirección MAC, por ejemplo) para actuar de forma individual dependiendo del
que se trate? Eso permitiría muchas cosas, como permisos, por ejemplo. Espero tu respuesta que, desde ya, te
agradezco.
Un saludo
A ver si me puede echar un cable porque no se que mas modificar.. ¡Muchas gracias!
PD.: Su página está genial la he recomendado mucho a compañeros y amigos que también se dedican a esto!
Reply –>Me di cuenta que cuando escribia “AT” en el monitor serie y apretaba enter, arduino en vez de leer un ‘\n’ leia el enter
como basura(una ‘y’ pero con dos puntitos arriba). Como no logré que reconociera el ‘\n’ le puse “while(c != ‘Z’) y al final
de cada comando AT escribí con un Z: (por ejemplo, “ATZ” en vez de “AT”). no es muy elegante pero funcionó para
identificar ese problema.
Si no les funciona el codigo podrian verificar que efectivamente estan saliendo de ese while y no estan en un loop infinito
:3
–>En la parte que dice “return( S + ‘\n’);” borré ” +’\n’ y ahi recien empezé a recibir respuestas del modulo. (por lo que
infiero que el modulo tampoco estaba leyendo los ‘\n’ como saltos de linea).
Mandandole “AT” en vez de “AT\n” el modulo reconoció los comandos :3
Si alguien sospecha que el problema es el modulo y no el arduino comprueben que efectivamente BT1.available() es en
algun momento TRUE, si no, puede ser que los comandos AT que le envian esten mal escritos (como en el caso de
“AT\n”) y que por lo tanto el modulo no entregue una respuesta y BT1.available() nunca sea TRUE.
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Espero que a alguien le haya servido. Si alguien me quere explicar mas en detalle por que me paso esto, o si es que
estoy infiriendo mal el funcionamiento del modulo, bienvenido sea
GIVE A REPLY
Message
URL
Post comment
WordPress
WordPress Anti-Spam
Anti-Spam by
by WP-SpamShield
WP-SpamShield
Home
El Módulo BlueTooth HC-05
OBJETIVOS
Presentar un montaje y programa que nos permite entrar directamente en modo de configuración de
comandos AT..
MATERIAL REQUERIDO.
ARDUINO MODULO
UNO REV 3 BLUETOOTH
HC-05
Añadir al
carrito Añadir al
carrito
CABLES
DUPONT
MACHO-
HEMBRA
Añadir al
carrito
En la sesión anterior presentamos algunos conceptos básicos sobre las redes Bluetooth y las funciones que se suelen realizar con ellos. Presentamos
el concepto de Master y Slave y configuramos el modulo HC-06 que solo podía trabajar en el modo Slave.
En esta sesión, vamos a utilizar su hermano mayor el modulo HC-05, que puede configurarse tanto como Master que como Slave, y que además
El aspecto externo es bastante similar y la mejor manera de diferenciarlos es por los pines el soporte, 4 para el HC-06 y 6 pines para el HC-05.
En la última sesión insistimos en que no hay diferencias hardware entre ambos modelos, pero sí que hay diferencias muy importantes en el firmware
(La programación interna del módulo).
Además, mientras que el HC-06 entra en modo de programación en cuanto lo enciendes y mientras no haya nadie conectado por Bluetooth, el HC-05
es ligeramente más complicado de colocar en modo comandos y requiere una cierta manera de arrancado, concretamente requiere que el pin KEY,
(Que no estaba conectado el caso del HC-06) este en HIGH cuando encendemos el modulo.
He visto bastante información he internet que recomendaba unos ciertos procesos para arrancar el modulo que siempre me han parecido confusos y
tienden a despistar a los que se acercan al tema por primera vez.
Por eso hemos decidido implementar este procedimiento en un Sketch de Arduino, para que podamos correrlo cuando necesitemos programar el
módulo.
El procedimiento normal con estos módulos, suele ser conectarlos, ver la configuración y reprogramarlos con nuestras preferencias. Después
mantendrá la programación hasta que decidamos cambiarla.
Pero parece que el proceso da bastante guerra, así que vamos a ver si podemos ayudar.
La conexión es muy sencilla aunque requiere algún cable más que el modulo HC-06, y algún cambio:
El consumo del módulo es mínimo y nuestro Arduino es capaz de alimentarlo sin problemas, por eso el modulo se encenderá cuando pongamos HIGH
en el pin 9. Esto nos permitirá poner en HIGH el pin digital 8, al iniciar nuestro programa y después levantar el pin 8, de este modo cuando arranque
entrara sin más en el modo de comandos AT.
El resto de los pines se conectan de forma similar a lo que hicimos en la sesión anterior. Txd y Rxd se deben conectar cruzados con los pines de
comunicación de Arduino, que usaremos mediante la librería software Serial.
El pin State refleja, supuestamente, la situación en la que se encuentra el modulo y por ahora no vamos a utilizarlo.
PROGRAMA DE CONTROL
Así pues, no tenemos nada nuevo en el programa excepto que alimentaremos el modulo desde el pin digital 8, para forzarle a entrar en el modo
comandos AT. Nuestro programa quedaría poco más o menos así: Prog_71_1
void loop()
{ if (BT1.available())
Serial.write(BT1.read());
if (Serial.available())
BT1.write(Serial.read());
}
Con este procedimiento garantizamos que el modulo HC-05 entra solo en modo AT comandos, y que nuestra consola nos va a servir para
programarlo, y confío en que nos evite todas las complicaciones.
Mi HC-05 me envía a la consola un mensaje de Status en cuanto arranca en el modo AT, si es vuestro caso deberíais ver un mensaje en la consola.
Si no es así, o veis signos raros, suele ser indicador de que la velocidad de comunicación entre Arduino y el modulo es incorrecta.
Id probando velocidades hasta que veáis algún mensaje correcto. Enviar un AT siempre debería recibir una respuesta de OK.
Confío en que si hemos seguido los pasos anteriores cuando abras la consola deberías recibir un mensaje del módulo directamente, y si no, basta con
que escribáis AT Intro, recibiréis un OK como muestra la captura de pantalla:
El mensaje que obtengáis no tiene por qué ser el mismo e incluso puede que no tengáis ningún mensaje en absoluto, pero es importante que os
aseguréis de que tenéis seleccionado Ambos NL&CR para terminar las líneas.
El modulo HC-6, finaliza los comandos por tiempo y por eso en la sesión anterior usamos GetLine para conseguir líneas completas. Pero el HC-05, no
hace esto sino que espera que la línea acabe educadamente en \r\n y entonces ejecuta el comando.
Aparentemente el número de modificaciones de software con la que se venden estos módulos es bastante
elevada y por ello no es fácil garantizar nada con ellos.
Aparentemente todos los módulos que he probado aceptan ordenes similares, pero no todos los módulos
aceptan todas las ordenes,(Supongo que dependiendo del Firmware).
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Cuando menos si escribís en mayúsculas AT e intro, deberías recibir una respuesta de OK en la consola. Y si es así podemos seguir viendo más
comandos.
AT+NAME, Requiere que nos informe del nombre que tiene asignado el modulo. Debería devolvernos un mensaje del tipo +NAME=HC-05,
indicando que se llama HC-05.
El modulo HC-06 se podía renombrar exactamente así, pero no podíamos preguntarle qué nombre tenía
asignado. Solo cambiarlo.
AT+NAMEXXXX, programa el nombre que queremos presentar cuando alguien nos localice:
AT+NAMECharly
AT+BAUD, nos permite solicitar la velocidad a la que está programado el modulo para hablar con Arduino, y AT+BAUDX, Fija la velocidad de
comunicación entre el modulo y la consola de acuerdo a la siguiente tabla:
1 configura 1200bps
2 configura 2400bps
3 configura 4800bps
4 configura 9600bps (Default)
5 configura 19200bps
6 configura 38400bps
7 configura 57600bps
8 configura 115200bps
AT+PINXXXX, configura el número de identificación personal, que se requerirá para establecer la vinculación
Recordad que el PIN es el número de identificación personal, que usaremos al conectarnos al módulo, pues
exigirá conocer la contraseña.
Básicamente estos son los mismos comandos que aceptaba el modulo HC-06 pero el HC-05 acepta bastante más.
ROLE=0 (Esclavo)
He visto muchos ejemplos por internet que indican que se debe usar un = para asignar valores, por ejemplo
AT+ROLE=1, o que para pedir información de la velocidad hay que hacer AT+BAUD?, También he visto que
varias páginas aseguran que para cambiar el PIN hay que hacer AT+PSSWD.
Yo no he sido capaz de que nada de eso me funcione así, y sin embargo en mi modulo funciona la sintaxis
que os escribo en los ejemplos. Tengo que suponer que hay diferentes Firmwares que modifican la sintaxis
porque no puedo creer que haya tantas nomenclaturas erróneas corriendo por la red.
No tendría demasiado sentido revisar aquí todos los posibles comandos AT, y por eso he preferido mostrar media docena de ellos, los más típicos,
para que podáis experimentar y configurar el modulo.
AT COMMAND LISTING
COMMAND FUNCTION
COMMAND FUNCTION
Para aquellos que sientan curiosidad por saber que más se puede hacer con los comandos AT (Alguien habrá, ¿No?), les remito a un documento de
Instructables que incluye un listado mayor de ellos. La dirección es:
Referencia comandos AT
Cuando hayamos programado el modulo como deseemos, podemos retirar la conexión del pin rotulado como KEY y el HC-05 está listo para trabajar
normalmente sin aceptar ya comandos AT.
Atención
Es importante comprender, que en cuanto conectemos algún dispositivo a nuestro modulo Bluettotth HC-05, la luz roja dejará de parpadear y
automáticamente saldremos del modo de comandos AT para entrar en el de transporte de información, es decir, cualquier cosa que le enviemos,
incluyendo comandos AT, se consideraran texto plano que se reenviará al otro extremos de la conexión Bluetooth.
RESUMEN DE LA SESIÓN
Hemos visto las diferencias con el módulo HC-06 y que a diferencia de este, se puede configurar como
maestro o como esclavo.
También hemos visto que acepta bastantes mas ordenes en comandos AT.
Hemos presentado un montaje que fuerza a entrar en el modo AT al módulo cuando arranca. Una vez
programado podemos soltar el pin KEY y el modulo estará listo para el servicio.
Anterior Siguiente
Un saludo.
Reply
He configurado UART=38400
role =0 . Si pongo role=1 no puedo sincronizar-lo con el mobil.
GIVE A REPLY
Message
URL
Post comment
WordPress
WordPress Anti-Spam
Anti-Spam by
by WP-SpamShield
WP-SpamShield
OBJETIVOS
Ver como podemos usar ArduDroid para controlar Arduino desde el movil.
MATERIAL REQUERIDO.
ARDUINO MODULO
UNO REV 3 BLUETOOTH
HC-05
Añadir al
carrito Añadir al
carrito
CABLES
DUPONT
MACHO- KIT DE
HEMBRA RESISTENCIAS
VARIADAS
Añadir al
carrito Añadir al
carrito
KIT 5X RGB
LEDS
Añadir al
carrito
Una vez que hemos visto cómo usar los comandos AT para programar los módulos Bluetooth, en las sesiones anteriores, podemos pasar a la parte
fácil que es usar nuestros móviles Android para controlar cualquier proyecto con BlueTooth. Es tan sencillo como conectarnos al módulo y escribir un
pequeño programa que gobierne el flujo de control.
Podríamos hacerlo con comandos de texto directos, pero es demasiado poco elegante y aquí nos gustan las cosas presentables, por lo que vamos a
usar un programa de lo más simpático, disponible para Android que se llama ArduDroid.
Básicamente es un programa Android con botones y deslizadores, más un esquema de programa Arduino que podemos usar para enviar y recibir
comandos de una forma presentable, y que además funciona muy bien.
Para ello necesitaremos que descarguéis ArduDroid de la GooglePlay para Android y lo instaléis en vuestro teléfono.
Siento tener que decir, de nuevo, que los módulos HC-05 y HC-06 no son capaces de conectar
con los móviles de Apple o al menos yo no lo he conseguido
Después basta con conectar cualquiera de los dos módulos a nuestros Duinos con un par de cables para GND y Vcc más Rxd y Txd.
Vamos a dedicar esta sesión a ver como conectamos uno de los módulos para la conexión normal de trabajo y cómo usar el Ardudroid para gobernar
mensajes de texto, pines digitales y ya puestos algún pin PWM.
DIAGRAMA DE CONEXIÓN
Vamos a montar inicialmente un pequeño circuito con tres diodos LED para que veamos cómo controlarlos desde el móvil, y luego iremos
complicando un poco más el montaje (No, no es una amenaza).
Ardudroid incluye un programa Arduino, que podemos utilizar como esqueleto para nuestros propios proyectos. Pero nosotros vamos a hacer algunos
Creo que ya comentamos que si usamos los pines 0 y 1 nuestro código funcionara, pero anularemos la
conexión con el PC vía USB, que usa los pines 01 y 1.
El autor, que es un hombre de mundo, no tiene problemas, porque prueba los programas con un segundo
módulo BT, y cuando tiene el programa pulido, no necesita volver a reprogramar, pero yo soy un poco más
torpe y prefiero no cerrar esa puerta mantener abierto el USB para mensajes por ejemplo.
Vamos a ir presentando el programa de control de Arduino en pequeñas dosis para evitar asustar a nadie, y que los sufridos lectores huyan
despavoridos, y de ese modo, además, podremos ir viendo poco a poco las diferentes secciones del programa, que estoy seguro ayudara a su mejor
comprensión.
En primer lugar, necesitamos saber, que el programa Ardudroid envía todos los comandos con una sintaxis sencilla. Todas las ordenes empiezan por *
y terminan en #, y si la orden incluye múltiples datos, esto vienen separados por el símbolo |
Por eso, porque las órdenes se envían codificadas, vamos a empezar con algunas definiciones previas:
Además usaremos la librería SoftwareSerial, para hablar con el modulo BlueTooth, mediante los pines digitales 2 y 3:
#include <SoftwareSerial.h>
SoftwareSerial BT1(3, 2); // RX | TX
Definiremos unas variables para contener los valores que leeremos del comando:
int ard_command = 0;
int pin_num = 0;
int pin_value = 0;
El cuerpo principal del loop es muy sencillo, Vamos a empezar recibiendo mensajes de texto:
if (get_char != START_CMD_CHAR)
return; // Si no hay *, vuelta a empezar
Recuerda que parseInt (), va leyendo caracteres hasta llegar a uno que no es un numero valido y entonces devuelve en un entero las cifras que ha
leído.
Una vez que leemos ard_command, evaluamos que tipo de comando es, y si la orden es de tipo texto, llamamos a un viejo conocido GetLine () para
conseguir el String:
Si lo que recibimos es una orden que corresponde al boton GetData , enviamos algo, previamente pactado, por ejemplo la lectura de A0 (Aunque no
tenemos nada conectado en este momento:
He preferido procesar las órdenes con funciones, fuera del cuerpo principal para que sea un poco más limpio el programa.
La función GetLine es la habitual, simplemente modificada para leer de BT1 en lugar de Serial:
String GetLine()
{ String S = "" ;
if (BT1.available())
{ char c = BT1.read(); ;
while ( c != END_CMD_CHAR) //Hasta que el caracter sea END_CMD_CHAR
{ S = S + c ;
delay(25) ;
c = BT1.read();
}
return( S ) ;
}
}
Para manejar los comandos de escritura analogica, mediante PWM, tenemos, otro apartado de lo mas sencillo:
if (ard_command == CMD_ANALOGWRITE)
{ analogWrite( pin_num, pin_value );
// add your code here
return; // De vuelta alloop();
}
Hemos presentado el programa ArduDroid. Una aplicación de lo más simpática para manejar vuestros
proyectos a través del móvil.
Anterior Siguiente
(37) Comments
Reply
GIVE A REPLY
URL
Post comment
WordPress
WordPress Anti-Spam
Anti-Spam by
by WP-SpamShield
WP-SpamShield
Copyright Prometec
Home
De Arduino A Tu PC Por BlueTooth
OBJETIVOS
MATERIAL REQUERIDO.
ARDUINO MODULO
UNO REV 3 BLUETOOTH
HC-05
Añadir al
Añadir al
carrito
carrito
CABLES
DUPONT
MACHO- KIT DE
HEMBRA RESISTENCIAS
VARIADAS
Añadir al
Añadir al
carrito
carrito
Una de las cosas más frecuentes cuando utilizas tu Arduino es usarlo como Data Logger, es decir como un sistema de recolección de datos
procedentes de un sistema cualquiera para su estudio o proceso posterior.
Una de las maneras más típicas es usar lector de tarjetas SD para que se pueda retirar al cabo de un tiempo, pero a nivel doméstico o a pequeña
escala es más sencillo usar un enlace Bluetooth para recibir esos datos en tu PC y almacenarlos allí directamente.
Otra ventaja d este método es que podemos gobernar nuestros circuitos Arduino directamente desde un PC de control, y eso incluye pequeños
robots o motores.
Es igual de sencillo conectar nuestro PC a los Arduinos con Bluetooth como lo ha sido hasta ahora para conectarlos a un teléfono móvil, y en
muchas ocasiones bastante más práctico.
En esta sesión vamos a instalar un adaptador >Bluetooth a nuestro PC (En el caso de que no lo tengáis incluido) y luego vincularlo al módulo BT del
Arduino.
DIAGRAMA DE CONEXIÓN
Si hacemos doble clic en el símbolo de Bluetooth mostrara los dispositivos BT visibles alrededor.
El icono de la izquierda, representa mi Arduino (Cuyo nombre es Charly) y si ya has conseguido vincularlo al PC, recordara los datos de conexión para
la próxima vez. El procedimiento es en todo similar a vincular unos auriculares Bluetooth.
Si hacéis doble clic en el icono os mostrara la venta de propiedades y si elegís la pestaña de Hardware, os mostrará la puerta COM que ha levantado
para él. En mi casa COM11:
Es un programa con muchas opciones (Lo que no debe asustaros) y que sirve para casi cualquier cosa que envié datos en Stream, incluyendo puertas
series, TCPIP y además acepta conexiones seguras SSH, y encima es gratis.
En mi caso le pido que guarde todo en un fichero llamado putty.log y que pise el anterior si existe (Para no pasarme la vida diciéndole que puede
sobrescribirlo).
Si pinchamos ahora en Terminal, seleccionad que fuerce el hecho en lo que recibimos y también en lo que enviamos, y eso es todo
Al hacerlo veréis que el testigo piloto del módulo Bluetooth deja de parpadear quedándose fijo. Indica que se ha establecido la comunicación.
EL PROGRAMA DE CONTROL
El programa de gestión de la conexión es de lo más sencillo. Vamos a aceptar en nuestro Arduino 3 órdenes que corresponden a los pines 13,12 y 11.
Cuando recibamos un numero de pin, invertiremos el estado del mismo pasando el LED de apagado a encendido y viceversa.
Como siempre cargamos la librería serie y creamos la puerta BT1 para comunicar con el Bluetooth
#include <SoftwareSerial.h>
SoftwareSerial BT1(3, 2); // RX | TX
void setup()
{ Serial.begin(9600);
BT1.begin(57600);
}
Después vamos a usar la función GetLine de nuevo para enviar líneas completas al PC desde la consola de Arduino y una versión modificada de la
misma llamada GetLineBT para hacer lo mismo a través de la puerta BT1.
if (BT1.available())
{ B= GetLineBT();
Serial.println(B);
}
if (Serial.available())
{ String S = GetLine();
BT1.println(S);
Serial.println(S);
}
Es lo de siempre, leemos lo que entra por Bluetooth y lo enviamos a la puerta serie. A su vez enviamos a BT1 lo que escribimos en la consola.
GetlLineBT tiene una particularidad y es que no busca el fin de línea como intro o ‘\n’ sino que busca
retorno ‘\r’ pues Putty tiene la manía de terminar las líneas con ‘\r’ en lugar de ‘\n’ y no he sido capaz de
encontrar como cambiar esto.
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Si algún alma caritativa descubre la forma agradecería que me informara.
Para gobernar los LEDS utilizamos el siguiente código, que simplemente invierte el valor del pin digital correspondiente cuando recibe la instrucción
pertinente.
if (B =="13")
digitalWrite(13, !digitalRead(13));
if (B =="12")
digitalWrite(12, !digitalRead(12));
if (B =="11")
digitalWrite(11, !digitalRead(11));
Y por ultimo para recibir los valores de las puertas analógicas A0,A1 y A2 cada 3 segundos usamos:
if (millis() % 3000 == 0)
{ BT1.println("Analog 0 = " + String(analogRead(A0))) ;
BT1.println("Analog 1 = " + String(analogRead(A1))) ;
BT1.println("Analog 2 = " + String(analogRead(A2))) ;
BT1.println(".................");
}
Vimos como configurar Putty para conectar tu PC y Arduino mediante Bluetooth, incluyendo activar el
Logging para guardar registro de la información que se recibe o envía.
Hemos presentado un pequeño programa que nos permite gobernar Arduino mediante órdenes enviadas
desde el PC y además recibe lecturas directamente.
Copyright Prometec
Home
Bluetooth 4.0 Low Energy
OBJETIVOS
Presentar las Apps que permiten esta comunicación con Apple IOS y Android
MATERIAL REQUERIDO.
9.60€ + + IVA
IVA
ARDUINO MODULO
UNO REV 3 BLUETOOTH
HC-10 BLE
Añadir al
Añadir al
carrito
carrito
CABLES
DUPONT
MACHO-
HEMBRA
Añadir al
carrito
Ya hace algún tiempo que estuvimos probando los módulos Bluetooth V2 con nuestros Arduinos y hay varias sesiones previas dedicadas a este tema
y a jugar con unos pequeños módulos como el HC-05 y el HC-06.
Estos módulos BlueTooth son muy sencillos de manejar y se comportan como receptores simples que nos envían por una puerta serie todo lo que
recibe y emiten mediante el BlueTooth todo lo que les enviemos a dicha puerta serie.
Actualmente este tipo de módulos son muy baratos, y sencillos de manejar lo que les convierte en unos componentes ideales para enviar datos a
nuestros Arduinos desde cualquiera de los móviles que llevamos en el bolsillo.
Pero había un problema. Los equipos de Apple no aceptan la conexión con este tipo de módulos porque aparentemente requieren la versión 4.0 del
Bluetooth y rechazan las versiones previas como la 2.0 que eran bastante frecuentes hasta hace relativamente poco.
En sesiones previas hicimos algunas pruebas para vincular nuestros teléfonos o tabletas Bluetooth 2.0 con Arduino, pero Apple siguiendo su
costumbre iba por libre y no había manera de conectar.
Pero con el tiempo han ido apareciendo módulos como los que conocemos que soportan el protocolo Bluetooth V4.0 o Low Energy al alcance de
todos los bolsillos y los fabricantes chinos han empezado a suminístrarlos de forma accesible, tales como los modelos HC-08 y HC-10.
Como ya hace algún tiempo conseguí uno de estos modulitos HC-08, ha llegado el momento de hacer pruebas con él y ver lo que pasa y comprobar
que podemos usar nuestros IPhone e Ipad para conectar con nuestros Arduinos.
¿Qué es el nuevo Bluetooth 4.0? Pues un nuevo protocolo diseñado pensando en disminuir todo lo posible las necesidades de energía de los
dispositivos que lo usan, y de sobre todo de la propia comunicación que tradicionalmente ha sido de consumo insaciable.
Se le suele llamar también BLE por Bluetooth Low Energy, o simplemente Bluetooth LE . No he conseguido demasiada información en internet
sobre los consumos reales que podemos esperar, en primer lugar porque hay muchos factores que pueden modificar ese consumo y en segundo lugar
porque no parece haber muchas ganas de mojarse con el tema.
Pero en realidad lo que de verdad me interesaba era la posibilidad de usar mi IPhone o Ipad con Arduino sin tener que empeñar un ojo para pagar el
modulito BlueTooth y aquí estamos con ello.
No quiero dejar pasar la ocasión de comentar, que aparentemente además de disminuir el consumo de energía de estos módulos, también ha bajado
la distancia a la que se puede hacer una comunicación efectiva con este nuevo protocolo, de los 100m anteriores a la mitad actualmente, aunque no
he podido probarlo por mí mismo.
Tal vez si algún lector que conozca del tema nos puede ilustrar con comentarios al respecto, que serían muy bienvenidos.
Es un pequeño modulo muy al estilo de los que ya conocemos y de patillaje muy similar, que nos convierte la información que llega vía BT a puerta
serie y viceversa:
Podemos hacer un pequeño montaje para entrar en modo de comandos AT y probar la comunicación con el modulo Bluetooth. Para ello basta
con arrancarlo mientras mantenemos en HIGH su pin ENABLE. La conexión es completamente similar a la que usamos con el modulo HC_06:
Comando Funcion
AT Devuelve OK
AT+BAUDn
Nota: EL modulo debe ser reseteado para que el cambio de velocidad se establezca
Seguro que me habré dejado más de un comando disponible, pero estos módulos no están demasiado bien documentados y para complicar más la
situación los diferentes fabricantes pueden cargar diferentes juegos de comandos AT dependiendo de sus gustos. Así que tendréis que probar que
comandos aceptan o no.
La conexión del módulo es trivial y vasca con alimentarlo y conectar la puerta serie:
void setup()
{ Serial.begin(9600);
Serial.println("Enter AT commands:");
BT1.begin(9600);
}
void loop()
{ if (BT1.available())
Serial.write(BT1.read());
if (Serial.available())
{ char c = Serial.read() ;
Serial.print(c);
BT1.print(c);
}
}
Ahora vamos a necesitar una aplicación que nos permita enviar mensajes entre nuestro Arduino y digamos un IPhone por ejemplo. Uno podría
pensar que algo así no tendría dificultad, pero localizar esta aplicación me ha llevado un par de horas, durante las cuales me he frustrado con todo
tipo de aplicaciones inútiles que no hacían más que marear.
Finalmente he encontrado una que cumple bastante bien con la misión de enviar y recibir menajes de texto entre Arduino y mi IPhone 4S, se llama
JBWave y podéis descargarla de la appStore sin problemas.
Para que no todo sea fácil y Apple pueda dar por el saco suficientemente, me he encontrado con que esta
aplicación corre bien en mi IPhone 4S, pero no en mi Ipad 3.
Aquí os dejo un pequeño video ilustrando el proceso de conexión y envió de mensajes en ambas direcciones:
Ya habíamos visto cómo usar las versiones previas de Bluetooth con teléfonos Android en sesiones anteriores, pero ya que estamos presentando la
conexión con la nueva versión Bluetooth 4.0 de baja energía, o BLE, dejaríamos la sesión un poco coja sin pasar revista al mismo tema con los
teléfonos de Google.
Esto viene causado porque la App que veíamos en la sesión de la HC-05 llamada BT SPP, no reconoce el nuevo formato y por eso debemos
presentar otra que realice las mismas funciones.
En este pequeño video os mostramos el use de la App con el HC-08 para pasar mensajes de texto entre nuestro Arduino y el móvil Android
Pues eso es todo por hoy, confío en que veáis que es igual de fácil usar el nuevo protocolo con los Iphone que con los Android.
RESUMEN DE LA SESIÓN
Hemos visto las diferencias con el los modulos que ya conociamos como el HC-05 y HC-06.
Hemos visto que Apps usar para transeferir mensajes mediante Android y Apple IOS.
Anterior Siguiente
Copyright Prometec
ÍNDICE GPRS
Los módulos GPRS
Home
ÍNDICE GPRS
Copyright Prometec
Home
MÓDULO GSM/GPRS: Llamar Y Enviar SMS
OBJETIVOS
MATERIAL REQUERIDO.
9.60€ + + IVA
IVA
CABLES
DUPONT
MACHO- CARGADOR
MACHO ARDUINO
Añadir al
Añadir al
carrito
carrito
GSM Y GPRS
Hemos visto varias formas de conectar nuestro Arduino al exterior, como Ethernet y wifi, pero puede que alguna vez queramos comunicarnos con él
y no tengamos acceso a ninguna de estas redes, o no queramos depender de ellas. Puede ser muy útil, por ejemplo, para colocar en una estación
meteorológica.
Para este tipo de propósitos podemos utilizar un módulo GSM/GPRS con una tarjeta SIM, de forma que podamos comunicarnos con él como si se
tratase de un teléfono móvil. Y es que esta tarjeta basada en el módulo SIM900 nos permite enviar y recibir llamadas y SMS y conectarnos a
EL GSM (Global System for Global Communications ) es el sistema de comunicaciones que más se utiliza en teléfonos móviles y es un estándar en
Europa. La primera funcionalidad de esta tecnología es la transmisión de voz, pero también permite la transmisión de datos (SMS, Internet), eso sí,
a una velocidad muy baja de 9kb/s.
El GPRS (General Packet Radio Service) es una extensión del GSM basada en la transmisión por paquetes que ofrece un servicio más eficiente para
las comunicaciones de datos, especialmente en el caso del acceso a Internet. La velocidad máxima (en teoría) del GPRS es de 171kb/s, aunque en la
práctica es bastante más pequeña.
Esta tarjeta está basada en el módulo SIM900, y la configuraremos y controlaremos vía UART utilizando los comandos AT.
Lo primero tendremos que colocar la tarjeta SIM que vayamos a usar. El adaptador para las tarjetas es del tamaño de las SIM normales, que en su
mayoría han sido sustituidas por MicroSIM y NanoSim, así que tendremos que hacernos con una o enganchar una de estas últimas en un adaptador
(el módulo que utilizamos en la sesión y que podéis conseguir en la tienda de esta página incluye adaptadores para todos los tamaños de tarjeta) .
Con un poco de paciencia y de pericia también podríamos colocar una nano o una micro directamente, pero en correremos peligro de que se mueva y
deje de hacer contacto.
Antes de conectar nada al Arduino, vamos a colocar los jumpers que tiene la tarjeta de forma que utilicemos para comunicarnos los pines 7 y 8.
Para conectarla a nuestro Arduino tenemos dos opciones, y para las dos necesitaremos una fuente de alimentación externa, ya que con conectar el
Arduino por USB será suficiente para encender el módulo, pero no para alimentar también la tarjeta. Si conectamos la alimentación externa al shield
GPRS y alimentamos el Arduino con el USB o una fuente aparte, sólo tendremos que unir los pines 7 y 8 para la comunicación serie y el GND entre
ambas tarjetas.
Si utilizáis un Arduino Mega, la conexión sería de los pines 7 y 8 del GPRS a los pines 10 y 11 del Mega.
En la programación también habría que cambiar la instrucción en la que definimos la instancia Software
Serial que creamos y ponerle los pines 10 y 11 (lo recordaremos más adelante).
Para activar la alimentación de la tarjeta SIM también nos encontramos con dos opciones. Podemos hacerlo manualmente presionando el
pulsador que hay en uno de los laterales durante uno o dos segundos y veremos que se enciende otro LED, y que uno de los que se había encendido
antes empieza a parpadear una vez por segundo. Este parpadeo nos indica que está buscando la red. Cuando la encuentre y se conecte cambiará la
frecuencia de parpadeo y lo hará cada 3 o 4 segundos. Eso sí, no se conectará hasta que no metamos el PIN de la SIM, que ya veremos ahora cómo
hacerlo.
También podemos activarla por programa, pero antes tendremos que realizar una soldadura en el pad “R13” que está justo al lado de la regleta de
pines roja “J16”. Y una vez hecho esto la activaremos mandando un pulso de 1 segundo al pin 9 de la tarjeta. Así que si queréis usar este tipo de
activación tendréis que añadir un cable entre un pin digital (en nuestro caso el 9) y el pin 9 de la tarjeta que hemos conectado. Eso sí, recordad que
si está activada la tarjeta y volvemos a meter el pulso, lo que haremos será apagarla.
Para comunicarnos con el módulo utilizaremos comandos AT, pero lo primero que haremos será incluir la librería SoftwareSerial.h y configurar la
comunicación por los pines 7 y 8 (10 y 11 para el Arduino Mega) .
#include <SoftwareSerial.h>
SoftwareSerial SIM900(7, 8); // 10 y 11 para el Arduino Mega. Configura el puerto serie para el SIM900.
El módulo utiliza una velocidad de comunicación de 19200KHz, así que en el setup configuraremos el puerto serie para el SIM900 y para Arduino a
esa velocidad.
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Además introduciremos el PIN de la tarjeta para desbloquearla utilizando comandos AT y le daremos un poco de tiempo para que se conecte a la red.
El comando que utilizaremos es AT+CPIN=“XXXX “, donde sustituiremos XXXX por el PIN de nuestra tarjeta.
Recordad que como vamos a meter el comando dentro de un println, tendremos que utilizar las \ antes de
cada “ para que no se comporten como un carácter especial.
void setup()
{
//digitalWrite(9, HIGH); // Descomentar para activar la alimentación de la tarjeta por Software
//delay(1000);
//digitalWrite(9, LOW);
delay (5000); //Nos damos un tiempo para encender el GPRS y la alimentación de la tarjeta
SIM900.begin(19200); //Configura velocidad del puerto serie para el SIM900
Serial.begin(19200); //Configura velocidad del puerto serie del Arduino
Serial.println("OK");
delay (1000);
SIM900.println("AT+CPIN=\"XXXX\""); //Comando AT para introducir el PIN de la tarjeta
delay(25000); //Tiempo para que encuentre una RED
}
Crearemos una función en la que meteremos las instrucciones necesarias para llamar y colgar la llamada, también mediante comandos AT. Para
llamar usaremos el comando ATDXXXXXXXXX, (sustituyendo las X por el número al que queramos llamar) y para colgar ATH.
No hay que ser tacaño con el tiempo que mantenemos la llamada, porque a veces puede tardar en empezar a dar tono y sino podríamos colgar antes
de recibir nada en nuestro móvil.
Y ya sólo tenemos que llamar a la función cuando nosotros queramos. En este ejemplo simplemente hacemos que llame una vez y se quede en
espera indefinidamente.
void loop()
{
llamar(); //Realiza la llamada
while (1);
}
La programación para enviar un SMS va a ser idéntica, pero crearemos otra función que se encargará de mandar los comandos AT para enviar el
SMS.
Primero usaremos el comando AT+CMGF=1\r para indicarle al módulo GPRS que vamos a mandar un mensaje, y a continuación introducimos el
número al que va dirigido con el comando AT+CMGS = “XXXXXXXXX”.
Una vez hecho esto simplemente le enviamos el contenido del mensaje y lo finalizamos con el caracter ^Z. La función quedaría así:
void mensaje_sms()
{
Serial.println("Enviando SMS...");
SIM900.print("AT+CMGF=1\r"); //Configura el modo texto para enviar o recibir mensajes
delay(1000);
SIM900.println("AT+CMGS=\"XXXXXXXXX\""); //Numero al que vamos a enviar el mensaje
delay(1000);
SIM900.println("SMS enviado desde un Arduino. Saludos de Prometec."); // Texto del SMS
delay(100);
SIM900.println((char)26); //Comando de finalización ^Z
delay(100);
SIM900.println();
delay(5000); // Esperamos un tiempo para que envíe el SMS
Serial.println("SMS enviado");
}
(217) Comments
Reply
Reply
Saludos.
Reply
Reply
Te cuento, tengo el microfono conectado a la salida que dice mic, y el auricular al otro, los inverti de lugar para ver que
tal y nada, el unico momento en el que se escucha algo(en el movil desde el cual llamo) es el ruido que crea la placa al
mover el micro o el auricular, será que la configuracion de red de argentina es la que no permite que se escuche nada?
porque por lo que estuve investigando varios de aqui les pasa lo mismo, tenes idea como seguir mi investigacion para
solucionarlo?
Reply
2)Que version de firmware tiene el suyo y como podria averiguar la version del mio?
3)Yo estoy haciendo que el sim este recibiendo llamadas, el sim contesta mis llamadas, con eso bien, el unico problema
es que durante la llamada no se escucha nada, (tengo conectados unos auriculares y un microfono de pc conectados al
sim900 que funcionan correctamente y probe con varios mas para cerciorarme), no se escucha nada desde el telefono
que llama, ni desde el sim900, cual podria ser mi problema?
Les agradezco de antemano y disculpen por tantas preguntas, pero son unos de los pocos de habla hispana que saben
sobre estas cosas y ademas responden, por eso los sigo jaja
Reply 1) El datasheet del chip lo encontrarás fácilmente, pero el del shield yo al menos no lo encuentro.
2) No lo he probado así que no sé decirte. Veo por ahí que ATI sirve para obtener información del shield. Pruébalo a
ver…
3) En teoría para recibir llamadas y escucharlas vale con que estés conectado a la red. No te haría falta más código
que el necesario para eso. Yo he probado y he podido escuchar bien. Igual es una tontería, pero ¿puede ser que hayas
enchufado el micrófono donde los cascos al revés?
Reply
Reply
Reply
void setup()
{
SIM900.begin(19200); //Configura velocidad del puerto serie para el SIM900
Serial.begin(19200); //Configura velocidad del puerto serie del Arduino
Serial.println(“OK”);
delay (1000);
SIM900.println(“AT+CPIN=\”1111\””); //Comando AT para introducir el PIN de la tarjeta
delay(25000); //Tiempo para que encuentre una RED
}
void mensaje_sms()
{
Serial.println(“Enviando SMS…”);
SIM900.print(“AT+CMGF=1\r”); //Comando AT para mandar un SMS
delay(1000);
SIM900.println(“AT+CMGS=\”54267957\””); //Numero al que vamos a enviar el mensaje
delay(1000);
SIM900.println(“SMS enviado desde un Arduino. Saludos de prometec.”);// Texto del SMS
delay(100);
SIM900.println((char)26);//Comando de finalizacion ^Z
delay(100);
SIM900.println();
delay(5000); // Esperamos un tiempo para que envíe el SMS
Serial.println(“SMS enviado”);
}
void loop()
{
mensaje_sms(); //Envia SMS
while (1); // Espera por tiempo indefinido
}
GIVE A REPLY
Message
Post comment
WordPress
WordPress Anti-Spam
Anti-Spam by
by WP-SpamShield
WP-SpamShield
Copyright Prometec
Home
MÓDULO GSM/GPRS: Recibir Llamadas Y SMS
OBJETIVOS
MATERIAL REQUERIDO.
9.60€ + + IVA
IVA
CABLES
DUPONT
MACHO- CARGADOR
MACHO ARDUINO
Añadir al
Añadir al
carrito
carrito
RECIBIR LLAMADAS
Ya vimos en la sesión anterior cómo conectar y poner en marcha el módulo GPRS, y si alguien probó en ese momento a llamar a la tarjeta que
tenemos colocada en el SIM900, habrá visto como da tono normalmente.
Sin embargo no habrá visto nada que indique que se está recibiendo una llamada, aunque si nos fijamos veremos como uno de los LEDs de la tarjeta
se apaga mientras se recibe. Así que lo que vamos a hacer es que nos avise mediante el monitor serie cuando las reciba.
char incoming_char = 0; //Variable para guardar los caracteres que envía el SIM900
En el loop simplemente comprobaremos que se están enviando caracteres desde el SIM900 y los iremos mostrando por el monitor serie.
void loop()
{
if (SIM900.available() > 0)
{
incoming_char = SIM900.read(); //Guardamos el caracter que llega desde el SIM900
Serial.print(incoming_char); //Mostramos el caracter en el monitor serie
}
}
Si ahora probáis a hacer una llamada al número que tengáis en la tarjeta del SIM900 veréis que en el monitor serie mostrará la palabra “RING” una
vez por cada tono, y terminará con un “NO CARRIER”.
#include <SoftwareSerial.h>
SoftwareSerial SIM900(7, 8); // 10 y 11 para el Arduino Mega. Configura el puerto serie para el SIM900
char incoming_char = 0; //Variable para guardar los caracteres que envia el SIM900
void setup()
{
//digitalWrite(9, HIGH); // Descomentar para activar la alimentación de la tarjeta por Software
//delay(1000);
//digitalWrite(9, LOW);
delay (5000); //Nos damos un tiempo para encender el GPRS y la alimentación de la tarjeta
SIM900.begin(19200); //Configura velocidad del puerto serie para el SIM900
Serial.begin(19200); //Configura velocidad del puerto serie del Arduino
Serial.println("OK");
delay (1000);
SIM900.println("AT + CPIN = \"XXXX\""); //Comando AT para introducir el PIN de la tarjeta
delay(25000); //Tiempo para que encuentre una RED
Serial.println("PIN OK");
SIM900.print("AT+CLIP=1\r"); //Activamos la identificación de llamada.
delay(1000);
}
void loop()
{
if (SIM900.available() > 0)
{
incoming_char = SIM900.read(); //Guardamos el caracter que llega desde el SIM900
Serial.print(incoming_char); //Mostramos el caracter en el monitor serie
}
}
Para recibir también correctamente los SMS, sólo tenemos que incluir un par de comandos AT más en el setup. Uno ya lo conocemos de la sesión
anterior, que configura el módulo para poder enviar y recibir SMS “AT+CMGF=1\r”. Y también incluiremos el comando “AT+CNMI=2,2,0,0,0\r” que lo
configura para que nos envíe por el puerto serie los SMS que nos lleguen.
char incoming_char = 0; //Variable para guardar los caracteres que envía el SIM900
void setup()
{
//digitalWrite(9, HIGH); // Descomentar para activar la alimentación de la tarjeta por Software
//delay(1000);
//digitalWrite(9, LOW);
delay (5000); // Nos damos un tiempo para encender el GPRS y la alimentación de la tarjeta
SIM900.begin(19200); //Configura velocidad del puerto serie para el SIM900
Serial.begin(19200); //Configura velocidad del puerto serie del Arduino
Serial.println("OK");
delay (1000);
SIM900.println("AT + CPIN = \"XXXX\""); //Comando AT para introducir el PIN de la tarjeta
delay(25000); //Tiempo para que encuentre una RED
Serial.println("PIN OK");
SIM900.print("AT+CLIP=1\r"); // Activamos la identificación de llamadas
delay(1000);
SIM900.print("AT+CMGF=1\r"); //Configura el modo texto para enviar o recibir mensajes
delay(1000);
SIM900.print("AT+CNMI=2,2,0,0,0\r"); //Configuramos el módulo para que nos muestre los SMS recibidos por comunicacion serie
delay(1000);
}
void loop()
{
if (SIM900.available() > 0)
{
incoming_char = SIM900.read(); //Guardamos el caracter que llega desde el SIM900
Serial.print(incoming_char); //Mostramos el caracter en el monitor serie
}
}
En la siguiente sesión utilizaremos lo que hemos aprendido para que nuestro Arduino se ponga en contacto con nosotros si fuera necesario, y a que
realice ciertas órdenes utilizando llamadas y SMS, y asegurándonos de que sólo responda ante nosotros.
RESUMEN DE LA SESIÓN
(44) Comments
Reply
Reply
Reply En mi caso, recibo las llamadas, pero no recibo los SMS. La consola al principio me escupe esto:
OK
PIN OK
AT+CPIN=”****”
OK
AT+CLIP=1
OK
AT+CMGF=1
OK
AT+CNMI=2
Reply
Reply Solo quería consultar, como puedo contestar una llamada que le haga al módulo y entablar una conversación estable
entre mi telefóno y el sim900? necesito que el módulo responda automáticamente y mantenga la llamada hasta que
desde el telefóno decida cortarla.
Saludos!
V 03 Feb 2017
Gracias por tu aporte es muy útil, quería hacer una consulta ! Estoy usando el SIM900 para activar o desactivar algo ,
cuando reciba un SMS , sé que debo usar el comando AT+ CNMI 2,2,0,0,0 , al realizarlo funcionaba correctamente y en
Reply el serial podía ver el texto del SMS q recibía el módulo pero de pronto , ya no recibe nada ! Ni ejecuta ninguna accion!
Probé el envío de mensajes y lo realiza correctamente pero no la recepción , es posible q se haya averiado únicamente
esa opción? Consideras q algo este mal en el código ? Porfa ayúdame
Reply
Reply
Reply Si usas un Mega no conviene que utilices librerias para manejar puertos serie.
Solo la usabamos con el arduino UNO para no cortar la posibilidad de actualizar el programa
Reply Estoy haciendo un proyecto con la placa de “Arduino Mega 2560” y una “SIM900”. He hecho el mismo programa que nos
habeis mostrado y cuando envio el mensaje desde mi movil, en la pantalla me aparece, “OK”, “PIN OK” y ya esta, no me
aparece lo siguiente, que es desde que numero se envia el mensaje y el mensaje mismo.
He conectado dos cables por salida, uno al RX1 y el otro al TX1, como me ha dicho mi profesor, pero no se porque el
Saludos,
Salu2!.
Un saludote!
Prueba a utilizar los pines 10 y 11, es decir, conecta los pines 7 y 8 del GPRS a los pines 10 y 11 de Arduino Mega, y
cambia esta instrucción SoftwareSerial SIM900(7, 8); por esta SoftwareSerial SIM900(10, 11); y me cuentas a ver.
Y si no ahora que me he dado cuenta, el Arduino Mega tiene varios puertos serie, podrías utilizar cualquiera que no
sea el 1 (0 Rx y 1 Tx), aunque no se si estás familiarizado con esto.
“Y si no ahora que me he dado cuenta, el Arduino Mega tiene varios puertos serie, podrías utilizar cualquiera
que no sea el 1 (0 Rx y 1 Tx), aunque no se si estás familiarizado con esto.” -> Pues no. No lo estoy y
realmente me gustaría saber a que te refieres. En la placa tengo puestos los conectores RX y TX en SWSerial.
¿?
Un saludote!
Un saludote.
Saludones!
Yo no he probado a usarlo con un Mega, pero no debería haber problema en teoría. De todas formas cuando me
contestes eso seguimos mirando a ver. La programación la he comprobado por si acaso y funciona correctamente
(usando un UNO). Un saludo.
Si envías los SMS y las llamadas correctamente significa que Arduino es capaz de enviarle órdenes
al GPRS, pero parece que en tu caso no recibe los datos que deberían llegarle desde el GPRS.
¿Estás utilizando el mismo módulo GPRS que he usado yo para la sesión? Comprueba también
que tengas bien puesto los bridges para usar los pines 7 y 8 y correctamente enchufados los
cables, no vaya a ser que esté mal colocado alguno. un saludote!
GIVE A REPLY
Message
URL
Copyright Prometec
Home
ENVIAR Y RECIBIR LLAMADAS Y SMS
OBJETIVOS
MATERIAL REQUERIDO.
9.60€ + + IVA
IVA
CABLES
DUPONT
MACHO- CARGADOR
MACHO ARDUINO
Añadir al
Añadir al
carrito
carrito
OPTIMIZAR EL PROGRAMA
En las sesiones anteriores dedicadas al GRPS hemos visto cómo conectarlo correctamente y los comandos AT necesarios para enviar y recibir
llamadas y SMS de una forma bastante sencilla. Sin embargo, para el que se haya fijado, aunque los comandos AT se envían correctamente y el
módulo cumple la función que buscamos, hay algunas cosillas que se pueden mejorar.
A esto podríamos añadir que, siendo el GPRS un módulo orientado hacia proyectos autónomos y sin supervisión, no tendremos acceso al monitor
serie (hasta ahora lo hemos supervisado desde ahí) , no estaremos seguros de que las cosas estén yendo bien y estemos realmente conectados a la
red móvil.
Y por último, podría ser que durante el periodo que tengamos funcionando nuestro proyecto perdiera la alimentación del Arduino o del GPRS, o se
desconectase de la red móvil por alguna razón. Así que también vamos a implementar una serie de funciones para que sea capaz de reiniciarse y
configurarse de forma autónoma, y de que se asegure que estemos conectados a la red antes de enviar llamadas o SMS.
Para poder reiniciarlo de esta forma y dotarle de autonomía es imprescindible haber realizado la soldadura que habilita el encendido por software
del módulo GPRS mediante un pulso en el pin 9, y conectarlo al pin 9 de Arduino que usaremos para ello (ya hablamos de esto en las sesiones
anteriores).
Al parecer el error al recibir algunas respuestas de los comandos AT por el monitor serie se debe a que enviamos el comando siguiente antes de
recibir la respuesta, y los “delays” no parecen solucionarlo, sino todo lo contrario (como casi siempre).
Por lo tanto crearemos una función sendATcommand2 con los siguientes objetivos:
int x = 0;
bool correcto = 0;
char respuesta[100];
unsigned long anterior;
return correcto;
}
Esta estructura condicional la usaremos para verificar que realmente estemos conectados a la red móvil, aunque podríamos usarlo en todos los
comandos AT para que, en caso de que algo falle, nos saque un mensaje por pantalla indicándonos dónde está el error. Realmente no totalmente
necesario ya que leyendo el monitor serie se puede ver dónde falla con sólo mirar las respuestas a los comandos AT.
Ya hemos hablado anteriormente acerca de cómo encender y apagar el módulo sin tener que presionar el pulsador del GPRS, enviando un pulso de
un segundo desde Arduino al pin 9 de la tarjeta. Sin embargo, imaginad que enviamos las instrucciones para encenderlo y resulta que ya estaba
encendido. Lo que haríamos sería apagarlo.
Así que vamos a crear también una función para encender el módulo pero comprobando antes que no está encendido ya. Es muy sencillo, si
enviamos el comando “AT” y nos devuelve OK es que estaba encendido. Si no devuelve nada tendremos que enviar el pulso para encenderlo.
pinMode(9, OUTPUT);
digitalWrite(9, HIGH);
delay(1000);
digitalWrite(9, LOW);
delay(1000);
Complementariamente a esta función vamos a crear otras dos muy sencillitas, una que apague el módulo y otra que incluya estás dos que para
reiniciar el módulo, y que usaremos si perdemos la conexión a la red.
void reiniciar()
{
Serial.println("Conexion a la red perdida. Reiniciando el modulo...");
power_off();
delay (5000);
power_on();
}
También tenemos funciones que ya hemos usado anteriormente, pero que tenemos que adaptar a la filosofía de esta sesión. Es decir, enviaremos los
comandos AT utilizando la función que hemos creado y comprobaremos que estemos conectados correctamente a la red móvil.
Estas funciones son las que usamos para configurar el módulo correctamente y las que propiamente realizan el envío de las llamadas y los SMS.
void iniciar()
{
enviarAT("AT+CPIN=\"1867\"", "OK", 1000);
Serial.println("Conectando a la red...");
delay (5000);
void mensaje_sms()
{
if (enviarAT("AT+CREG?", "+CREG: 0,1", 1000) == 1) //comprueba la conexion a la red
{
Serial.println("Enviando SMS...");
enviarAT("AT+CMGF=1\r", "OK", 1000); //Comando AT para mandar un SMS
sprintf(aux_str, "AT+CMGS=\"XXXXXXXXX\"", strlen(sms)); //Numero al que vamos a enviar el mensaje
//Texto del mensaje
if (enviarAT(aux_str, ">", 10000) == 1)
{
enviarAT(sms, "OK", 10000);
}
Serial.println("SMS enviado");
}
else
{
reiniciar();
iniciar();
}
}
void llamar()
{
if (enviarAT("AT+CREG?", "+CREG: 0,1", 1000) == 1) //Comprueba la conexion a la red
{
Serial.println("Realizando llamada...");
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Serial.println("Realizando llamada...");
enviarAT("ATDXXXXXXXXX;", "OK", 1000);
delay(20000); // Espera 20 segundos mientras realiza la llamada
enviarAT("ATH", "OK", 1000); // Cuelga la llamada
Serial.println("Llamada finalizada");
}
else
{
reiniciar();
iniciar();
}
}
Una vez hemos creado las funciones que vamos a necesitar, la estructura del programa no tiene nada demasiado complicado. Con este programa
realizaremos una llamada al teclear una “l” en el monitor serie y enviaremos un SMS con la letra “s”. Evidentemente también recibiremos llamadas y
SMS y mostraremos la información de ambas en pantalla, del número de teléfono y del contenido del mensaje en el caso de que sea un SMS.
#include <SoftwareSerial.h>
SoftwareSerial SIM900(7, 8); // Configura el puerto serial para el SIM900. Para el Arduino MEGA utilizar pines 10 y 11
int respuesta;
char aux_str[50];
void setup()
{
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
{
SIM900.begin(19200); //Configura velocidad del puerto serie para el SIM900
Serial.begin(19200); //Configura velocidad del puerto serie del Arduino
delay(1000);
Serial.println("Iniciando...");
power_on();
iniciar();
}
void loop()
{
if (Serial.available())
switch (Serial.read())
{
case 'l':
llamar();
break;
case 's':
mensaje_sms();
break;
}
if (SIM900.available()) {
Serial.write(SIM900.read());
}
}
Con este programa creemos que ya podréis afrontar vuestros proyectos con mayores garantías de éxito, otorgándoles un cierto nivel de autonomía y
confianza. La estructura de tipo switch() que hemos creado nos da la posibilidad de incluir de forma muy sencilla otros casos en los que sean las
lecturas de ciertos sensores las que activen las llamadas o los SMS, e incluso podrías incluir en estos últimos el valor de las lecturas dentro del texto
del SMS en el caso que sea necesario.
A enviar correctamente los comandos AT y asegurarnos de recibir la respuesta del módulo GPRS.
Hemos creado un programa para recibir y enviar llamadas y SMS, al que hemos dotado de capacidad
de trabajar de forma autónoma con ciertas garantías de éxito.
Reply Tengo una duda, al usar el comando AT+CGATT=1, me da error, y de ahi en adelante los comandos AT+CGATT=1 y el
AT+CIICR me dan error, de casualidad tienes alguna sugerencia,
Saludos Cordiales
Reply
GIVE A REPLY
Message
URL
Post comment
WordPress
WordPress Anti-Spam
Anti-Spam by
by WP-SpamShield
WP-SpamShield
Home
CONTROLAR ARDUINO MEDIANTE LLAMADAS Y SMS
OBJETIVOS
MATERIAL REQUERIDO.
9.60€ + + IVA
IVA
CABLES
DUPONT
MACHO- CARGADOR
MACHO ARDUINO
Añadir al
Añadir al
carrito
carrito
Con lo que hemos aprendido hasta ahora seguro que a muchos de vosotros ( yo incluido) se os ha ocurrido que podríamos montar un sistema que,
por ejemplo, encienda la calefacción de casa un ratillo antes de que lleguemos haciéndole una llamada con nuestro móvil, y así estemos bien a
gustito en casa según lleguemos.
Pues en esta sesión vamos a ir acercándonos a eso. Primero utilizando una llamada para encender y apagar un LED , y después para hacer lo propio
en función del SMS que le enviemos.
Primero vamos a centrarnos en las llamadas. El concepto del programa será guardar en una variable el texto que recibamos del puerto serie del
GPRS y si es una llamada, encender o apagar un LED alternativamente. Pero claro, no queremos que nadie que no seamos nosotros (u otra persona
autorizada por nosotros) se equivoque al llamar de número y ande encendiendo cosas en nuestra casa, así que crearemos una agenda con los
números que tienen nuestro beneplácito.
Además tendremos que crear una variable mensaje tipo String, donde iremos guardando los caracteres que nos vayan llegando del GPRS, con el fin
de poder luego trabajar con ellos.
char incoming_char = 0; //Variable que guarda los caracteres que envia el SIM900
String mensaje = "";
int LED = 13 ;
bool estado = false ; //Variable para guardar el estado del LED
String agenda[] = {"XXXXXXXXX" , "XXXXXXXXX"}; //Array con los numeros autorizados
int numtotal = 2; //Cantidad de numeros de telefono autorizados
Toda la parte de los programas que sirve para recibir las llamadas y los SMS correctamente va a ser el mismo que en la sesión anterior, sólo que esta
vez hemos metido toda la parte que se encarga de poner en marcha el módulo GPRS en una función a la que llamaremos inicializaSIM900 , y que
lanzaremos en el setup.
Y la recepción de caracteres va a ser también igual en el loop, sólo que esta vez iremos guardando los caracteres en una variable, como hemos
indicado un poco más arriba.
if (SIM900.available() > 0)
{
incoming_char = SIM900.read(); //Get the character from the cellular serial port.
Serial.print(incoming_char); //Print the incoming character to the terminal.
mensaje = mensaje + incoming_char ; // Añadimos el último caracter leído al mensaje
}
Una vez tenemos el mensaje completo, vamos a ver si es una llamada, y a buscar el número de teléfono para encender un LED si está autorizado.
Para esto vamos a utilizar una función .indexof(). Esta función nos devuelve la posición, mediante un número entero, de una cadena o carácter
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
dentro de una cadena de texto dada. En el caso de que no exista devuelve “-1”. La forma de usarlo es la siguiente:
Sabiendo esto crearemos una función identifica_llamada() para buscar primero el final de una llamada, y después el número de teléfono y si está
autorizado.
Si recordáis la sesión anterior, una llamada finaliza con “NO CARRIER” , así que lo primero que haremos será buscarlo y si existe buscaremos los
números de teléfono que hemos autorizado dentro del mensaje que hemos guardado. Si está autorizado cambiamos el estado del LED, y sino no
hacemos nada.
Y una vez hecho todo esto, borramos el contenido de la variable mensaje para dejarla libre para la siguiente llamada.
void identifica_llamada()
{
int finllamada = mensaje.indexOf("NO CARRIER"); //Buscamos el final de llamada
if (finllamada >= 0)
{
for ( int i = 0; i < numtotal; i++) { int pos = mensaje.indexOf(agenda[i]); //Buscamos el número en la agenda if (pos >=
0)
{
estado = ! estado ; // cambiamos el estado
digitalWrite(LED, estado) ;
Serial.println("\nEl numero esta autorizado");
}
}
mensaje = "" ; //Bórralo para la próxima vez
}
}
void setup()
{
pinMode( LED, OUTPUT) ; // LED como salida
inicializaSIM900();
}
void loop()
{
if (SIM900.available() > 0)
{
incoming_char = SIM900.read(); //Guardamos el carácter del GPRS
Serial.print(incoming_char); //Mostramos el carácter en el monitor serie
mensaje = mensaje + incoming_char ; // Añadimos el carácter leído al mensaje
}
identifica_llamada ();
}
Cuando hagáis pruebas os recomiendo dejar sonar más de un tono, por si acaso se perdiera algún carácter durante el envío y no recojamos bien el
número de teléfono. Con cada tono se manda una vez el número que nos está llamando, y así nos aseguramos de que alguna de las veces llegue
bien. No pasa muchas veces, pero todos conocemos las leyes de Murphy…
Con el SMS ya no vamos a necesitar buscar el final de la llamada ni autorizar números, porque nadie se va a equivocar y mandar un SMS con el texto
concreto a nuestro Arduino por equivocación (ya me parece bastante raro que alguien mande un SMS), aunque si buscáis máxima seguridad no os
sería muy difícil incluir también esa comprobación. Así que podemos prescindir de las variables que creábamos para ello.
Por lo demás el programa es exactamente igual, salvo la función final, que quedaría así:
void identifica_SMS()
{
int led_on = mensaje.indexOf("Encender LED"); //Buscamos el texto en el SMS
int led_off = mensaje.indexOf("Apagar LED"); //Buscamos el texto en el SMS
if (led_on >= 0)
{
digitalWrite( LED, HIGH) ;
Serial.println("\nLED ENCENDIDO");
mensaje = "" ; //Bórralo para la próxima vez
}
if (led_off >= 0)
{
digitalWrite( LED, LOW) ;
Serial.println("\nLED APAGADO");
mensaje = "" ; //Bórralo para la próxima vez
}
}
Ahora podéis combinar ambos si queréis que reaccione ante las dos cosas. Y si, como a mí, os siguen cobrando los SMS y no estáis por la labor de
pagar más, os propongo que contéis los tonos de la llamada y en función de cuántos sean, encendáis o apaguéis el LED. Recordad que con cada
tono el GPRS nos envía una cadena de caracteres “RING”.
A hacer un filtro en las llamadas para autorizar sólo algunos números basándonos en una agenda.
Reply
Reply
Reply
void loop()
{
//Comprueba el SIM800 a ver si hay SMS +++++++++++++++++++++++++++++++++++
if (SIM800.available()){
Comando=SIM800.readString();
Serial.println(“COMANDO LEIDO: ” + Comando);
Si yo le envío un SMS desde con mi móvil, siempre siempre lo promero que hace es escribir ALARMA MOVIMIENTO y
luego me reenvia el SMS.
Me activa el pin 2 y no lee el comando del SMS.
Es como si al recibir un SMS hubiese movimiento en el PIR y eso NO es así.
He hecho muchas variaciones del código pero siempre funciona igual. Llevo semanas con este problema.
¿Sabe que podría ser?
Muchas gracias por su tiempo.
Reply
Reply
void chequea_SMS()
{
int agregar = mensaje.indexOf(“Agregar”);
if (agregar >= 0)
{
String nuevo = “”;
for (int i = 0; i < 9; i++)
{
nuevo += mensaje.charAt(agregar + 8 + i);
}
agenda[numtotal] = nuevo;
Serial.println(“Numero agregado: ” + nuevo);
}
mensaje = "" ; //Bórralo para la próxima vez
}
Reply
ERROR
AT+CLIP=1
OK
AT+CMGF=1
OK
AT
Gracias!!
Reply
-Se tendrán varios numeros registrados y activada la identificacion de llamada del modulo GSM, esto para la agenda
telefonica.
-Si se recibe un llamada de uno de los numeros registrados se activara la alarma (altavoces y luces estroboscopicas).
-También se podran recibir msjs e identificar su contenido a fin de poder activar “reinicios parciales o totales” del
sistema:
a) Si se envia un mensaje que diga “Matenimiento”, parpadeara 3 veces un LED verde.
b) “Reset Programa”, reiniciara el programa.
-Una vez listo cualquier reinicio el sistema enviara un msjs de “Reinicio Completo”.
-El codigo tambien posee comandos de “WatchDog” como mecanismo de seguridad.
-Adicional, existen lineas de comando para mostrar la calidad de la señal o cobertura del GSM mediante el monitor serial
en la PC, a la hora de instalar el sistema.
-Asi mismo, poseera 3 leds indicadores de estados, un rojo para indicar que el arduino esta encendido, otro naranja para
indicar que el GSM esta encendido, y el verde anteriomente mencionado que estara siempre activado e indicara que el
codigo esta funcionando; este ultimo parpadera 3 veces al recibir un msjs que diga “Manteniento”, lo cual servira para
probar el GSM. EL codigo es el siguiente; cabe mencionar que lo he hecho en base a lo visto en las varias paginas de
este foro, pero necesito que alguien me diga si esta planteado, si asi como esta brinda todas las funciones que plantee,
y en si, que me digan si el codigo funciona para lo que ya describi del sistema, y de no ser asi, que me ayuden a
corregirlo por favor, de antemano muchas gracias!:
#include
#include
#include
SoftwareSerial SIM900(7, 8);
char incoming_char = 0;
String mensaje = “”;
int LED = 10;
int RELE = 11;
int RESET = 12;
char inSerial[256];
bool estado = false ;
String agenda[10] = {“+584267989946” , “+584249202682”};
int numtotal = 10;
void ShowSerialData()
{
wdt_reset();
if (Serial.available() > 0)
{ int i = 0;
while (Serial.available() > 0) {
inSerial[i] = (Serial.read());
void setup()
{
wdt_disable();
wdt_enable(WDTO_8S);
digitalWrite( LED, HIGH) ;
digitalWrite( RESET, HIGH) ;
delay(200);
pinMode( LED, OUTPUT) ;
pinMode( RESET, OUTPUT) ;
pinMode( RELE, OUTPUT) ;
pinMode(9, OUTPUT);
digitalWrite(9, HIGH);
delay(1000);
digitalWrite(9, LOW);
delay (5000);
SIM900.begin(19200);
Serial.begin(19200);
SIM900.print(“AT+CLIP=1\r”);
wdt_reset();
delay(1000);
SIM900.print(“AT+CMGF=1\r”);
delay(1000);
SIM900.println(“AT+CPIN=\”1234\””);
wdt_reset();
delay(7000);
wdt_reset();
delay(7000);
wdt_reset();
void identifica_llamada()
{
wdt_reset();
int finllamada = mensaje.indexOf(“NO CARRIER”);
if (finllamada >= 0)
{
for ( int i = 0; i = 0)
{
wdt_reset();
for ( int j = 0; j > 3 ; j++) {
digitalWrite( LED, HIGH) ;
delay(200);
digitalWrite( LED, LOW) ;
delay(200);
}
wdt_reset();
digitalWrite( LED, HIGH) ;
mensaje = “” ;
}
if (reset1_on >= 0)
{
wdt_reset();
reiniciarGSM();
resetFunc();
enviar_sms();
delay(100);
if (reset2_on >= 0)
{
wdt_reset();
reiniciarGSM();
digitalWrite( RESET, LOW); //Este pin debe conectarse al pin de reset del arduino mediante una resistencia de 1Kohm
enviar_sms();
delay(100);
wdt_reset();
}
if (resetGSM >= 0)
{
wdt_reset();
reiniciarGSM();
}
wdt_reset();
}
void loop()
{
wdt_reset();
if (SIM900.available() > 0)
{
incoming_char = SIM900.read();
mensaje = mensaje + incoming_char ;
Reply
Reply
Luego desde el loop() se guarda todo lo que se haya escrito en el serial SIM900 dentro de la variable:
incoming_char = SIM900.read();
Todo funciona correctamente, en la salida del Monitor Serial me muestra lo siguiente, como se esperaba:
OK
AT+CMGR=1
+CMGR: “REC READ”,”+34000000000″,””,”17/07/16,10:13:37+08″
Apagar LED
LED APAGADO
Mi duda es que esto solo se muestra una vez y se para, cuando debería mostrarse cada vez que el loop reinicie o sea si
incoming_char = SIM900.read(); está dentro del loop(), cada vez que el loop se reinicie, debería guardar lo que se lee en
el serial SIM900.
No se si lo que lee en el serial SIM900 una vez leido se borra automáticamente y el loop ya no guarrda nada en la
variable incoming_char.
GIVE A REPLY
Message
URL
Post comment
WordPress
WordPress Anti-Spam
Anti-Spam by
by WP-SpamShield
WP-SpamShield
Home
Conectarse A Internet Mediante GPRS
OBJETIVOS
MATERIAL REQUERIDO.
9.60€ + + IVA
IVA
CABLES
DUPONT
MACHO- CARGADOR
MACHO ARDUINO
Añadir al
Añadir al
carrito
carrito
Si habéis seguido las sesiones que hemos dedicado hasta ahora al GPRS, no vais a tener ningún problema con esta. Y si no las habéis leído, os
recomendamos que lo hagáis, porque vamos a pasar muy por encima las cosas que ya hemos explicado y vamos a reutilizar (con algunos cambios) la
mayoría de las funciones que ya hemos usado antes. Concretamente vamos a basarnos en el programa que utilizamos en la sesión dedicada a Enviar
y recibir llamadas y SMS.
int x = 0;
bool correcto = 0;
char respuesta[100];
unsigned long anterior;
return correcto;
}
pinMode(9, OUTPUT);
digitalWrite(9, HIGH);
delay(1000);
digitalWrite(9, LOW);
delay(1000);
void power_off()
{
digitalWrite(9, HIGH);
delay(1000);
digitalWrite(9, LOW);
delay(1000);
}
void reiniciar()
{
Serial.println("Reiniciando...");
power_off();
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
delay (5000);
power_on();
}
La función void iniciar(); en la que configuramos el módulo GPRS, la vamos a tener que cambiar para enviar los comandos AT que necesitamos para
conectarnos correctamente a Internet. Lo primero es que vamos a necesitar conectarnos a la red GPRS.
Aunque no lo hemos dicho claro hasta ahora, os habréis dado cuenta que en cuanto activamos la tarjeta y metemos el PIN correcto el módulo se
conecta a la red de forma automática. No hay más que esperar y comprobar que realmente lo haya hecho con el comando AT+CREG?.
Sin embargo para conectarnos a la red GPRS y adjuntarnos al servicio de paquetes que nos posibilite conectarnos a Internet tendremos que utilizar el
siguiente comando:
Una vez hecho esto tendremos que buscar en Internet el nombre del punto de acceso o APN , usuario y contraseña de la operadora que estemos
usando. Una búsqueda rápida y en Google y lo encontraréis sin problemas.
Un APN (Access Point Name) es el nombre de un punto de acceso que hay que configurar para que nuestro
dispositivo se pueda conectar a Internet usando las redes de nuestra operadora.
AT+CSTT="Nombre del Punto de Acceso o APN","usuario","contraseña" // Definimos el APN, usuario y clave a utilizar
Y ahora usaremos un par de comandos para activar la conexión GPRS en función de lo que hemos configurado con el comando AT+CSTT, y
obtendremos nuestra dirección IP.
Y con esto ya tenemos todos los comandos que usaremos para configurar e iniciar el módulo:
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
void iniciar()
{
enviarAT("AT+CPIN=\"1867\"", "OK", 1000); //Introducimos el PIN de la SIM
Serial.println("Conectando a la red...");
delay (5000);
Serial.println("Conectado a la red.");
enviarAT("AT+CGATT=1\r", "OK", 1000); //Iniciamos la conexión GPRS
enviarAT("AT+CSTT=\"ac.vodafone.es\",\"vodafone\",\"vodafone\"", "OK", 3000); //Definimos el APN, usuario y clave a utilizar
enviarAT("AT+CIICR", "OK", 3000); //Activamos el perfil de datos inalámbrico
enviarAT("AT+CIFSR", "", 3000); //Activamos el perfil de datos inalámbrico
}
Hemos quitado los comandos AT que configuraban el módulo para el envío y recepción de llamadas y SMS
para simplificarlo; pero podéis integrarlos en esta misma función para juntar todas las funcionalidades.
Añadiendo alguna de las funciones de las que hemos comentado que se repetían de la sesión anterior, ya tenemos terminado el setup .
void setup()
{
SIM900.begin(19200); //Configura velocidad del puerto serie para el SIM900
Serial.begin(19200); //Configura velocidad del puerto serie del Arduino
delay(1000);
Serial.println("Iniciando...");
power_on();
iniciar();
}
Una vez hemos realizado correctamente la configuración, vamos a realizar la petición Http. El proceso va a ser prácticamente el mismo que para
mandar que para mandar un SMS. Lo primero cambiaremos la variable en la que teníamos el texto del SMS por la dirección Http a la que queremos
conectarnos de esta forma:
#include <SoftwareSerial.h>
SoftwareSerial SIM900(7, 8); // Configura el puerto serial para el SIM900. Para el Arduino MEGA utilizar pines 10 y 11
int respuesta;
char aux_str[50];
En ella indicamos el Host, en este caso www.prometec .net, y la página a la que queremos acceder: /prueba-http/ dentro del Host. Es decir sería lo
equivalente a acceder a www.prometec.net/prueba-http/.
Hemos creado esta página para hacer las pruebas. Simplemente contiene el título “PRUEBA PARA
CONEXIONES HTTP” y el mensaje “¡Enhorabuena! Has conseguido realizar una conexión HTTP sin utilizar
un navegador. Saludos desde Prometec.”
Aunque cuando hagamos la petición veréis que una página web contiene un montón más de cosas, y más si
está realizada en WordPress como la nuestra.
AT+CIPSTART //indicamos el tipo de conexión (TCP/UDP), la dirección IP y el puerto al que se realiza la conexión.
AT+CIPSEND //preparamos el envío de datos. Cuando esté listo devolverá el código ">" como inductor para el comienzo del envío.
Y ya en el loop() vamos a crear una estructura de tipo switch para enviar la petición cuando escribamos “h” en el monitor serie. Además incluiremos
la opción ce cerrar la conexión utilizando la tecla “q”:
Ya estamos preparados para cargar el sketch en nuestro Arduino, y si está todo correcto deberíamos ver cómo se va configurando en el monitor
serie:
RESUMEN DE LA SESIÓN
Hemos realizado una conexión Http sin utilizar un navegador, utilizando nuestro Arduino.
Podemos utilizar nuestro Arduino para conectarnos a Internet desde cualquier lugar en el que tengamos
cobertura de red móvil
(40) Comments
Reply Quería preguntar, hay alguna forma de usar el internet para no consumir datos móviles, es decir, gratis? Saludos y
muchas gracias!!
Reply
El tema es que yo lo tengo hecho con arduino ethernet, o el famoso nodemcu, pero ahora necesito este módulo, que
me entrega una conexión directa a internet.
Conectado a la red.
AT+CGATT=1
OK
AT+CSTT=”lte.avantel.com.co”,”Avantel LTE”,””
ERROR
AT+CIICR
ERROR
P.D. deseo mantener una conexión permanente con la red GPRS (IP local asignada), no una conexión TCP permanente
con mi servidor.
Gracias por su respuesta.
Si tu apn no lleva usuario ni contraseña supongo que bastará con pasarle Strings vacíos “”, pero no puedo probarlo
porque mi SIM si me los pide.
Un saludo.
Reply Los comandos AT son para cualquier operadora? Tiene algun tipo de restriccion por pais?
Saludos
Y en la petición http poner la dirección a la que quieres hacerla, terminado siempre en /, o sea:
Gracias!
Otra duda, he conseguido sincronizar la hora del sistema mediante el comando AT :AT+CNP, y lo muestro por pantalla
con AT+CCLK?, pero no se como almacenar el valor que me da AT+CCLK? para despues con la libreria Time.h poner en
hora mi arduino y despues sacar el tiempo en el que cada sensor toma la muestra para así poder hacer un seguimiento
en el tiempo de como varía.
Reply
Un saludo.
Reply
Reply
GIVE A REPLY
Message
URL
Post comment
WordPress
WordPress Anti-Spam
Anti-Spam by
by WP-SpamShield
WP-SpamShield
Home
ANEXO COMANDOS AT PARA GSM/GPRS Y GPS
Os dejamos una tabla con los comandos AT más usados en los módulos GSM/GPRS y GPS SIM900 y SIM808.
ATDXXXXXXX; Realiza una llamada. Sustituir XXXXXXXXX por el nº al que queramos llamar.
Configura el modo texto para enviar o recibir mensajes. Devuelve “>” como
AT+CMGF=1
inductor.
AT+CNMI=2,2,0,0,0 Configuramos el módulo para que muestre los SMS por el puerto serie.
para obtener los datos del GPS usando la especificación de la NMEA: Horario
AT+CGPSOUT=32 UTC,Estado,Latitud,Longitud,Velocidad en nudos,Ángulo de derrota en
grados,Fecha,Variación magnética,Datos del Cheksum
(46) Comments
Reply
Reply
Reply Saludos!
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply AT+VTD=xx
This command is optional, and is used to set the DTMF tone duration in 100mS steps.
AT+VTS=x
Reply Hace un tiempo vengo trabajando con un sim900 conectado a un arduino Mega. De momento he logrado conectarme a
Internet y enviar datos con un chip de una compañía, y no he tenido problemas. Por temas de costos, adquirí un chip de
otra compañía, pero resulta que esta ultima, para conectarse a Internet, requiere activar el roaming o itinerancia de
datos. Mi consulta es ¿Existirá algún comando que me permita activar el roaming desde el sim900?
Reply
Para ello vas a tener que convertir primero el int o el float que te devuelva el sensor a char.
Reply Para descolgar leo por ahí que es el comando “ATA” aunque no lo he probado. Si lopruebas ya nos contarás si
funciona. Un saludo.
Reply
Reply
Reply
GIVE A REPLY
Message
URL
Copyright Prometec
Home
ANEXO COMANDOS AT PARA GSM/GPRS Y GPS
Os dejamos una tabla con los comandos AT más usados en los módulos GSM/GPRS y GPS SIM900 y SIM808.
ATDXXXXXXX; Realiza una llamada. Sustituir XXXXXXXXX por el nº al que queramos llamar.
Configura el modo texto para enviar o recibir mensajes. Devuelve “>” como
AT+CMGF=1
inductor.
AT+CNMI=2,2,0,0,0 Configuramos el módulo para que muestre los SMS por el puerto serie.
para obtener los datos del GPS usando la especificación de la NMEA: Horario
AT+CGPSOUT=32 UTC,Estado,Latitud,Longitud,Velocidad en nudos,Ángulo de derrota en
grados,Fecha,Variación magnética,Datos del Cheksum
(46) Comments
Reply
Reply
Reply Saludos!
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply AT+VTD=xx
This command is optional, and is used to set the DTMF tone duration in 100mS steps.
AT+VTS=x
Reply Hace un tiempo vengo trabajando con un sim900 conectado a un arduino Mega. De momento he logrado conectarme a
Internet y enviar datos con un chip de una compañía, y no he tenido problemas. Por temas de costos, adquirí un chip de
otra compañía, pero resulta que esta ultima, para conectarse a Internet, requiere activar el roaming o itinerancia de
datos. Mi consulta es ¿Existirá algún comando que me permita activar el roaming desde el sim900?
Reply
Para ello vas a tener que convertir primero el int o el float que te devuelva el sensor a char.
Reply Para descolgar leo por ahí que es el comando “ATA” aunque no lo he probado. Si lopruebas ya nos contarás si
funciona. Un saludo.
Reply
Reply
Reply
GIVE A REPLY
Message
URL
Copyright Prometec
Home
Obtener Nuestras Coordenadas Con El Shield GPS
OBJETIVOS
MATERIAL REQUERIDO
IVA + IVA
EL SHIELD GPS
El Shield GPS de DuinoPeak está diseñado para convertirse en una interfaz sencilla y practica para dotar de posicionamiento GPS a
proyectos Arduino. Incluye una antena de GPS activa y nos permite seleccionar los pines que queremos usar para la comunicación serie entre D0 y
D7.
Además incluye un lector de tarjetas SD para grabar los datos que se registran del GPS mediante interfaz SPI, aunque esto lo dejaremos para la
próxima sesión. Y como nos suele gustar, tenemos una librería que nos facilita el trabajo muchísimo.
EL SHIELD GPS
Lo primero que vamos a hacer para empezar a trabajar con el shield es descargar su respectiva librería TinyGPSPlus-0.95. La librería incluye varios
ejemplos que podemos ejecutar directamente, aunque tendremos que hacerle alguna pequeña modificación. Para probarlo vamos a abrir el ejemplo
DeviceExample, que sirve para obtener nuestra localización y la fecha y hora actual.
Al principio del programa incluimos las librerías y declaramos los pines para la comunicación serie y la velocidad del GPS. Si habéis colocado los
jumpers como nosotros tendréis que cambiar los pines Rx y Tx por el 2 y el 3 respectivamente.
Por otra parte, la velocidad por defecto es de 4800 para el GPS, y nosotros no hemos conseguido hacerlo funcionar con ella. La única con la que
hemos conseguido que todo vaya bien 9600 baudios. Total, que tenemos algo como esto:
En el setup lo relevante es que tenemos que vamos a cambiar la velocidad del puerto serie también a 9600:
Serial.begin(9600);
ss.begin(GPSBaud);
En el loop comprobamos que nos llegue algo por el puerto serie que hemos conectado al shield, y si llega llamamos a la función displayInfo, con la
que mostramos los datos del GPS.
void loop()
{
// This sketch displays information every time a new sentence is correctly encoded.
while (ss.available() > 0)
if (gps.encode(ss.read()))
displayInfo();
Anterior Siguiente
GIVE A REPLY
Message
URL
Post comment
WordPress
WordPress Anti-Spam
Anti-Spam by
by WP-SpamShield
WP-SpamShield
Home
Utilizar El Data Logger Del Shield GPS
OBJETIVOS
MATERIAL REQUERIDO
IVA + IVA
IVA
POWERBANK
2.600 MAH
Leer más
Ahora que sabemos usar el shield para obtener los datos del GPS, vamos a centrarnos en otras características que nos ofrece. Concretamente en la
capacidad para grabar los datos en una tarjeta SD. Y como extra vamos a calcular la distancia desde nos encontramos al lugar que le indiquemos.
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Lo primero que tenemos que hacer es incluir las librerías y declarar las variables e instancias que vamos a usar después. La mayoría se repiten del
ejemplo anterior, y las que no lo hacen, son las que necesitamos para usar el data logger y la tarjeta SD.
Para poder usar el data logger tenemos que declarar una variable para indicar el chip que estamos usando. No os voy a engañar, cuando lo
intentamos no conseguimos encontrar información concreta de cuál es, pero un poco de prueba y error nos dio la solución, es el chip 8 . A parte de
eso, tenemos que dar nombre al archivo que usaremos para guardar los datos en la tarjeta, con la extensión .CSV .
#include <TinyGPS++.h>
#include <SoftwareSerial.h>
#include <SD.h>
const int chipSelect = 8;
File dataFile;
char filename[] = "LOGGER00.CSV";
En el setup tenemos que inicializar el GPS y la SD. Al hacerlo creamos un nuevo archivo en la SD y le damos un nombre con números correlativos,
para no borrar siempre el archivo anterior cuando vayamos a grabar uno nuevo.
Si hemos conseguido abrir la SD y grabar el archivo correctamente, escribimos las cabeceras de los campos que queremos mostrar y las mostramos
también en el monitor serie: latitud, longitud, altitud, velocidad, fecha, hora y distancia al objetivo que le marquemos.
Vamos a utilizar una “,” como separador para los campos para poder importarlos luego a una hoja de
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Excel.
void setup()
{
Serial.begin(9600);
ss.begin(GPSBaud);
Y ya en el loop obtenemos los datos del GPS y los vamos escribiendo en la SD. Una vez tengamos nuestra posición, le indicamos la posición objetivo
y calculamos la distancia a la misma. Hemos puesto como objetivo las coordenadas de Madrid.
void loop()
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
{
// Dispatch incoming characters
while (ss.available() > 0)
gps.encode(ss.read());
if (gps.location.isUpdated())
{
Serial.print(gps.location.lat(), 6);
Serial.print(F(","));
Serial.print(gps.location.lng(), 6);
Serial.print(F(","));
File dataFile = SD.open(filename, FILE_WRITE);
dataFile.print(gps.location.lat(), 6);
dataFile.print(F(","));
dataFile.print(gps.location.lng(), 6);
dataFile.print(F(","));
dataFile.close();
}
else if (gps.speed.isUpdated())
{
Serial.print(gps.speed.kmph());
Serial.print(F(","));
File dataFile = SD.open(filename, FILE_WRITE);
dataFile.print(gps.speed.kmph());
dataFile.print(F(","));
dataFile.close();
}
else if (gps.date.isUpdated())
{
Serial.print(gps.date.day());
Serial.print(F("/"));
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Serial.print(F("/"));
Serial.print(gps.date.month());
Serial.print(F("/"));
Serial.print(gps.date.year());
Serial.print(F(","));
File dataFile = SD.open(filename, FILE_WRITE);
if (gps.date.day()<10){ // Add a zero, if necessary, as above
dataFile.print(0);
}
dataFile.print(gps.date.day());
dataFile.print(F("."));
dataFile.print(gps.date.year());
dataFile.print(F(","));
dataFile.close();
}
else if (gps.time.isUpdated())
{
Serial.print(gps.time.hour());
Serial.print(F(":"));
Serial.print(gps.time.minute());
Serial.print(F(":"));
Serial.print(gps.time.second());
Serial.print(F(","));
File dataFile = SD.open(filename, FILE_WRITE);
if (gps.time.hour()<10){ // Add a zero, if necessary, as above
dataFile.print(0);
}
dataFile.print(gps.time.hour());
dataFile.print(F(":"));
last = millis();
}
}
Si abrimos el monitor serie podemos ver como funciona el GPS. Primero veremos si es capaz de acceder a la tarjeta y el nombre del archivo que va a
crear. A partir de ahí nos irá dando los datos que hemos obtenido del GPS.
Podéis meter los datos que hemos obtenido en el localizador de coordenadas de Google para ver si funciona correctamente. En nuestro caso la
precisión ha sido altísima:
Para probar el GPS en condiciones vamos a soltarlo del ordenador, colocarle una power bank (las baterías que se suelen usar para cargar los
móviles) y vamos a salir a dar una vuelta, a ver si todo funciona en condiciones.
Ahora abrimos una hoja nueva de Excel donde vamos a importar los datos que hemos guardado. Para ello vamos a “Datos”->”Obtener datos
externos”->”Desde texto”
Entonces os preguntará como son los campos. Le decimos que están delimitados. Y en la siguiente ventana le decimos que están delimitados por
Comas.
Ahora podéis utilizar estos datos con alguna de las aplicaciones que hay para dibujar el recorrido en un mapa usando Google Maps, o para lo que se
os ocurra. Pero eso os lo dejamos para vosotros.
Anterior Siguiente
Copyright Prometec
Home
SIM808: GSM/GPRS + GPS
OBJETIVOS
MATERIAL REQUERIDO.
Este módulo está basado en el chip SIMCOM SIM808 y nos ofrece, además de las funcionalidades de envío y recepción de datos GSM/GPRS (la de
los teléfonos móviles 2g), la tecnología GPS de navegación por satélite. O sea que, gracias a este módulo y utilizando una tarjeta SIM, seremos
capaces de enviar y recibir llamadas y SMS , conectarnos a Internet y conocer nuestras coordenadas y el horario UTC (Tiempo Universal
Coordinado).
Y por supuesto tiene conexión para cascos y micrófono para que podamos hablar con quien nos llame o cuando llamemos nosotros.
Así que si queréis, os recomendamos echar un ojo a sus respectivas sesiones Módulo GSM/GPRS SIM900.
Vamos a empezar por colocar en el módulo SIM808 la tarjeta SIM que vayamos a usar, que se pone en la parte de abajo de la placa. Es para tarjetas
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
SIM de las grandes, así o usáis una de esas o necesitaréis de un adaptador.
También deberíamos poner en el módulo las dos antenas que vienen con él, la del GPRS y la del GPS. En las conexiones de la placa vienen marcado
donde se conecta cada una de ellas.
Y ahora nos toca conectarlo al Arduino, para lo que usaremos los pines Tx y Rx de la tarjeta (transmisión y recepción de datos) , que conectaremos a
los pines 7 y 8 del Arduino respectivamente. Pueden ser otros pines cualesquiera, siempre que los soporte la librería Software Serial que vamos a
utilizar. Además uniremos las tierras y utilizaremos una fuente de alimentación externa para el módulo SIM808, ya que a la hora de comunicar este
tipo de módulos consume mucho y no será suficiente con la alimentación del Arduino.
Recordad que las conexiones Rx y Tx del módulo y del SIM808 deben ser cruzadas, es decir, el Rx
de uno al Tx del otro y viceversa para que se puedan comunicar de forma efectiva.
Y que no se os olvide unir las tierras de todos los componentes que uséis, o no funcionará.
Para poder comunicarnos vía comandos AT tendremos que cargar un programa para la comunicación serie como hemos hecho tantas veces
anteriormente. Crearemos una instancia llamada SIM808 y seleccionaremos los pines del Arduino que queramos usar para comunicarnos (Rx y Tx) .
Nosotros hemos elegido el 7 y el 8, pero podéis usar cualquiera que sea compatible con la librería. También podéis cambiar la velocidad de
#include <SoftwareSerial.h>
SoftwareSerial SIM808(7, 8); //Seleccionamos los pines 7 como Rx y 8 como Tx
void setup()
{
SIM808.begin(19200);
Serial.begin(19200);
delay(100);
}
void loop()
{
//Envíamos y recibimos datos
if (Serial.available() > 0)
SIM808.write(Serial.read());
if (SIM808.available() > 0)
Serial.write(SIM808.read());
}
Una vez hayamos cargado el programa abrimos el monitor serie y seleccionamos la velocidad correcta. El primer comando AT nos servirá
simplemente para saber si el módulo responde y que por lo tanto la comunicación funciona. Y este comando es simplemente AT, lo escribimos y
pulsamos INTRO. Debería respondernos con un OK; si no deberíamos repasar que esté todo en orden: conexiones, encendido y velocidad correcta.
Comprobado esto, ya podemos meter el PIN de la tarjeta SIM, que se hace mediante el comando AT+CPIN=”XXXX”; donde tendréis que sustituir
XXXX por el pin que corresponda, en mi caso 1867, o sea, AT+CPIN=”1867″. Obtendremos un mensaje de respuesta indicando si el PIN es correcto, y
en caso de que lo sea, el LED que parpadeaba una vez por segundo pasará a hacerlo cada 3 segundos (más o menos), indicando que ha encontrado
la red móvil.
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Y ahora ya estamos en disposición de enviar y recibir llamadas y conectarnos a Internet. Para comprobar que efectivamente podéis llamaros al
numero de teléfono de la SIM que hayáis puesto en el módulo, o usar el comando ATDXXXXXXXXX; (sustituyendo las X por el número de teléfono y
respetando el “;”) para llamar a quien queráis. Y si le conectáis unos cascos y un micrófono al módulo podréis hablar como si fuera un teléfono
normal.
Os dejamos una tabla con los comandos AT más utilizados con este tipo de módulos y enlaces a las sesiones de SIM900 donde ya tratamos eso,
porque los comandos AT son los mismos y la programación también.
La parte del GPS se controla igual, mediante comandos AT, y vamos a verlos usando el mismo programa que en el apartado anterior. Primero
activaremos el GPS mediante el comando AT+CGPSPWR=1. Y después preguntaremos por el estado del GPS hasta que veamos que ya nos ha
posicionado utilizando AT+CGPSSTATUS?. Cuando nos devuelva “Location 3D Fix” ya podremos seguir, lo que suele llevar unos 30 segundos la
primera vez.
Ahora ya estamos en posición de obtener los datos del GPSusando el comando AT+CGPSINF=0 que nos devolverá algo como esto: “+CGPSINF:
0,4316.645000,257.667700,14.800000,20170117141311.000,0,9,1.796440,198.850006″; que siguiendo ese orden corresponden a:
1. Modo: 0.
2. Latitud: 43º 16′ 64.5″.
3. Longitud: 2º 7′ 66 77″.
4. Altitud 14.8
5. Fecha en UTC: 20170117141311, o sea, 17 de enero de 2017 a las 14:13:11.
6. Tiempo de respuesta: 0.
También podemos usar AT+CGPSOUT=32 para obtener los datos del GPS pero usando la especificación de la NMEA (National Marine Electronics
Association), que define la interfaz entre varios equipos electrónicos marítimos. Con este comando recibiremos estos datos hasta que cerremos el
GPS usando AT+CGPSPWR=0.
Y si queréis comprobarlo buscad en Google “posición por coordenadas” o algo parecido e introducir los datos de latitud y longitud que hemos
obtenido. No es que tenga una precisión del 100% pero no está mal. Al menos a mí me ha localizado con un margen de error aceptable.
RESUMEN DE LA SESIÓN
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
En esta sesión hemos aprendido varias cosas importantes:
A utilizar la parte GSM/GPRS para enviar y recibir llamadas y mensajes y conectarnos a Internet.
Anterior Siguiente
(85) Comments
Reply
Reply
Reply
Reply
Reply
Reply
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Víctor 16 Nov 2017
Buenas noches, me queda una duda… còmo puedo hacer para que la latitud y longitud me aparezcan como número
flotante en vez de estar en formato NEMA?… Por favor… ayuda estoy usando el SIM808
Reply
Reply
Reply En mi caso solo estaría interesado en los datos GPS del módulo para poder comunicarlos a un centro de control de
semáforos para saber porque calle viene un vehículo. Seria posible usar el módulo sin la SIM? Y en caso afirmativo como
seria posible transmitir estos datos al centro de control de los semáforos?
Muchas gracias!
Estoy generando los comandos y viendo su respuesta a través del monitor serie del ID de arduino.
Me gustaría que me orientaran frente a este tema. Muchas Gracias Por SU Pronta Respuesta
Reply
Reply Ante todo gracias por tu web, sirve de mucha ayuda y está todo muy bien explicado y ordenado. Una pasada el curro que
te pegas, eskerrik asko!
Reply SI yo deseo enviar los datos del GPS, mas halla de separar las cadenas y organizar los datos, como se pueden enviar
dichos datos a un servidor. ¿Que comandos se deben utilizar? ¿que se debe tener en cuenta?
Reply
Reply El programa simplemente lee los comandos AT que luego le enviaremos por el puerto serie.
Cuando corre el código sin conectar la SIM, lo hace correctamente, guardando los tiempos y sin reiniciarse.
A que puede ser debido?
Saludos
Reply
GIVE A REPLY
Message
Post comment
WordPress
WordPress Anti-Spam
Anti-Spam by
by WP-SpamShield
WP-SpamShield
Copyright Prometec
Home
ANEXO COMANDOS AT PARA GSM/GPRS Y GPS
Os dejamos una tabla con los comandos AT más usados en los módulos GSM/GPRS y GPS SIM900 y SIM808.
ATDXXXXXXX; Realiza una llamada. Sustituir XXXXXXXXX por el nº al que queramos llamar.
Configura el modo texto para enviar o recibir mensajes. Devuelve “>” como
AT+CMGF=1
inductor.
AT+CNMI=2,2,0,0,0 Configuramos el módulo para que muestre los SMS por el puerto serie.
para obtener los datos del GPS usando la especificación de la NMEA: Horario
AT+CGPSOUT=32 UTC,Estado,Latitud,Longitud,Velocidad en nudos,Ángulo de derrota en
grados,Fecha,Variación magnética,Datos del Cheksum
(46) Comments
Reply
Reply
Reply Saludos!
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply
Reply AT+VTD=xx
This command is optional, and is used to set the DTMF tone duration in 100mS steps.
AT+VTS=x
Reply Hace un tiempo vengo trabajando con un sim900 conectado a un arduino Mega. De momento he logrado conectarme a
Internet y enviar datos con un chip de una compañía, y no he tenido problemas. Por temas de costos, adquirí un chip de
otra compañía, pero resulta que esta ultima, para conectarse a Internet, requiere activar el roaming o itinerancia de
datos. Mi consulta es ¿Existirá algún comando que me permita activar el roaming desde el sim900?
Reply
Para ello vas a tener que convertir primero el int o el float que te devuelva el sensor a char.
Reply Para descolgar leo por ahí que es el comando “ATA” aunque no lo he probado. Si lopruebas ya nos contarás si
funciona. Un saludo.
Reply
Reply
Reply
GIVE A REPLY
Message
URL
Copyright Prometec
Home
Los Módulos De Radio NRF2401
OBJETIVOS
Presentar un par de programas sencillos que nos permitan usarlos en nuestros proyectos para enviar y
recibir órdenes o datos.
MATERIAL REQUERIDO.
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
9.60€ + 3.60€ +
IVA IVA
ARDUINO
UNO REV 3 NRF24L01
Añadir al Añadir al
carrito carrito
CABLES
DUPONT
HEMBRA-
HEMBRA
Añadir al
carrito
Hemos visto en anteriores sesiones, que poder usar conexiones inalámbricas nos ofrece unas posibilidades a las que resulta difícil renunciar cuando
te acostumbras, y hemos hecho pruebas de conexiones tanto WIFI como Bluetooth.
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Las WIFI nos permiten conectarnos a Internet con facilidad y podemos publicar páginas Web con valores de nuestros sensores y Arduinos o
simplemente acceder a estos Duinos y pasarles parámetros u órdenes. EL BlueTooth es ideal si queremos controlar nuestros Arduinos sin más
controlador que un móvil que ya llevamos habitualmente en el bolsillo.
Pero tanto el BT como el WIFI tienen unas limitaciones considerables en lo que se refiere a la distancia a la que podemos usarlo. No pasa más allá
de 20 metros y eso en condiciones óptimas, pero no es raro que necesitemos más distancia, digamos 50 m, 0 200 m, y porque no un kilómetro.
Como siempre, cuando hay una necesidad en el mercado, surge alguien dispuesto a ofrecer una solución en forma de electrónica, y en esta ocasión
vamos a presentar una solución magnifica para el tipo de problema que planteamos. Un medio de dar órdenes a un Arduino o similar, a una distancia
que puede variar entre 50 metros y hasta digamos un kilómetro.
En esta sesión vamos a presentar y dar los primeros pasos con unos magníficos dispositivos de radio basados en el chip de Nordic semiconductor
NRF24, y que podemos encontrar en multitud de módulos de diferentes fabricantes, compatibles entre sí, por muy poco dinero, que es lo que nos
gusta en esta casa.
Este dispositivo NRF2401, integra en un único chip, toda la electrónica y bloques funcionales precisos, para establecer comunicaciones RF ( Radio
Frecuencia) entre dos o más puntos a diferentes velocidades, (Hasta 2 Mb/seg) con corrección de errores y protocolo de reenvió cuando es
necesario, sin intervención del control externo, lo que nos permite aislarnos de tobo el trabajo sucio y complicado relacionado con la transmisión
física.
El alcance depende de si hay visión directa entre los nodos, o por el contrario hay obstáculos, pero nos
ofrece un mínimo de unos 20 m hasta un máximo e 80m en óptimas circunstancias, en el modelo básico con
la antena integrada.
Podemos encontrar modelos con antenas más eficaces por un coste un poco superior (no mucho no os
asustéis) que aumentan de forma importante el alcance hasta casi un km.
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Si no queremos complicarnos la vida son muy fáciles de usar y configurar y además son los enlaces más
baratos que podemos encontrar para vincular nuestros Arduinos.
A finales del siglo XIX, James C. Maxwell estableció las leyes del electromagnetismo que describen la propagación de las ondas electromagnéticas y
la relación que existe entre los campos magnéticos y la electricidad (de ahí el nombre) estableciendo una de las teorías básicas que regulan el
funcionamiento del mundo moderno.
Todas la ubicuas emisiones de RF que nos rodean actualmente, fueron descritas por Maxwell y sus ecuaciones hace ya más de 100 años, y eso
incluye las emisiones de radio en AM y FM , las de televisiones, tanto analógicas como digitales, la conexión de tu teléfono móvil y hasta las
conexiones WIFI y Bluetooth de las que hemos hablado previamente.
Las primeras emisiones de radio viables se atribuyen en 1901 Guillermo Marconi y son el precedente de toda la tecnología de radio actual
apoyándose en los trabajos de Maxwell y Heinrich Hertz de quien deriva la unidad de medida de la frecuencia Hercios en español (Hertz en inglés)
La descripción de una onda de RF se realiza por su frecuencia, en Hercios, que indica el número de pulsos
por segundo a los que bate la señal, y por su amplitud que indica la intensidad.
Ya hemos hablado antes del espectro de frecuencia y vamos a destacar que en la práctica llamamos RF a las señales de frecuencia inferior a los
300Ghz
Nuestros humildes módulos NRF2401 emiten a 2.4 GHz , lo que es banda libre y no requieren de ningún permiso para usarse en ninguna parte del
mundo ( Por mucho que os quieran meter miedo con esto ). Pero a cambio, no tenemos garantía de que no haya alguien más emitiendo en esta banda
en las cercanías, lo que puede producir interferencias con nuestra emisiones.
Cuando sintonizas tu emisora FM en el dial, digamos 103.4, es porque la emisora paga a la administración
para ser la única que pueda emitir legalmente en esa frecuencia y de ese modo impida la interferencia de
otros servicios comerciales.
Por eso el espectro de radiofrecuencias está sometido a un estricto control administrativo, en todos los
países, para evitar que señales en competencia interfieran entre si anulando la posibilidad de transmitir
información valida.
Estos módulos usan el bus SPI para acelerar la conexión con el micro controlador por lo que vamos a ver la descripción de los pines necesarios para
su conexión, en vista superior:
Hay dos librerías básicas para el manejo de los NRF2401s en Arduino, la NRF24 que es la que vamos a usar aquí (Porque me parece más sencilla) y
la librería MIRF.
CE 3 9 9
CSN 4 10 53
SCK 5 13 52
MOSI 6 11 51
MISO 7 12 50
IRQ 8 2 –
Es importante recalcar que estos módulos funcionan a 3.3V; EL fabricante previene contra conectarles a 5V
so pena de achicharrarlos.
La librería MIRF espera que hagas unas conexiones de pines diferentes, así que no te conviene usar este
diagrama de conexión si pretendes utilizarla.
Tenéis que comprender que los modelos UNO y MEGA usan diferentes pines para el control del bus SPI y
luego para rematar la faena, según la librería cambian de nuevo.
Empezaremos haciendo la prueba más sencilla posible. Uno de ellos, el emisor, radia una serie de números y el otro, el receptor, los recibe y
muestra en la consola serie.
Aunque estos módulos consumen muy poco en uso o en Stand by, pueden absorber en el arranque más de
lo que la fuente de 3.3V de Arduino puede proporcionar, lo que impide que arranque correctamente o que
tenga un funcionamiento errático, especialmente en el caso del emisor.
Si buceáis en Internet, veréis cantidad de páginas recomendándoos usar unos condensadores entre los
pines tal y cual.
Aunque tomar precauciones nunca sobra, los vagos somos incapaces de hacer algo así, mientras no se
En mi caso he comprobado que la manera más sencilla de evitar problemas (Que los he tenido) ha sido
asegurarme de que el emisor tiene una alimentación correcta y abundante, mediante un alimentador
externo de los típicos. Esta sencilla precaución ha hecho que en mi caso los problemas se reduzcan hasta
desaparecer.
Vamos a montar un primer ejemplo en el que crearemos dos programas diferentes que corren en dos Arduino diferentes. El primero será el programa
emisor, que radiará números en secuencia desde 0 hasta el 255, y el segundo el programa receptor, que nos permitirá comunicarnos en una única
dirección inicialmente.
Vamos con el programa emisor y para ello necesitamos la librería RF24-master, cuya última versión siempre podéis encontrar en
https://github.com/maniacbug/RF24. Empezamos con unos cuantos includes, necesarios para el NRF2401 y para el bus SPI:
Después tenemos que crear una instancia de la radio, indicándole los pins de control, y la siguiente línea indica el pipe a utilizar, que podemos
imaginar como uno de los diferentes canales en los que la radio puede operar.
RF24 radio(9,10);
const uint64_t pipe = 0xE8E8F0F0E1LL;
El pipe es un numero de 64 bits, lo que indicamos con el tipo uint64_t , entero sin signo de 64 bits, y por si
no estuviera suficientemente claro, le indicamos al compilador que se trata de un LL al final del número, o
sea LongLong = 64 bits.
void setup(void)
{ Serial.begin(9600);
radio.begin();
radio.openWritingPipe(pipe);
}
En el programa principal, simplemente vamos incrementando una variable para luego transmitirla por la radio
void loop(void)
{ for (int x=0;x<2255;x++)
{ msg[0] = x ;
radio.write(msg, 1);
}
}
En cuanto al programa receptor Prog_79_1_Receptor, tenemos que empezar incluyendo las mismas librerías, y un array mínimo para el entero a
recibir, e instanciamos la radio como radio
#include <nRF24L01.h>
#include <RF24.h>
#include <RF24_config.h>
#include <SPI.h>
RF24 radio(9,10);
const uint64_t pipe = 0xE8E8F0F0E1LL;
int msg[1];
void setup(void)
{ Serial.begin(9600);
radio.begin();
radio.openReadingPipe(1,pipe);
radio.startListening();
}
Pero en vez de usar radio radio.openWritingPipe(pipe) para escribir, usamos radio.openReadingPipe(1,pipe) para poder leer y después
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
radio.startListening() nos permite comenzar la escucha. Y ya solo falta el setup con el programa que recibe:
void loop(void)
{ if (radio.available())
{ int done = radio.read(msg, 1);
Serial.println(msg[0]);
}
}
Se nos ha vuelto a perder la parte difícil, porque no me digáis que no es sencillo y elegante. El tema no da para más. Si corréis los programas en
Arduinos diferentes, la salida del receptor debería ser algo así:
Programa por el que no ganaremos ningún premio, pero que ilustra a la perfección como emitir datos numéricos uno a uno entre emisor y receptor
mediante radio frecuencia. Si habéis llegado hasta aquí, enhorabuena acabáis de emitir por radio, vuestro primer mensaje.
Bueno, está bien. Enviar un carácter esta chupado, pero ¿Que pasa si hay que enviar un String completo, seguro que la cosa se complica?
Pues sí. Para enviar un mensaje de texto tenemos que cambiar un par de cosas. Primero definir un array de char suficiente para que quepa el
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
mensaje:
char msg[16]="Prometec.net.\n" ;
void loop(void)
{
radio.write(msg, 16);
}
void loop(void)
{ if (radio.available())
{ int done = radio.read(msg, 16);
Serial.println(msg);
}
}
Basta con llamar a radio.write o radio.read con el array como parámetro y pasarle el número de caracteres que queremos enviar o recibir. Aquí tenéis
el emisor y el receptor modificados.
Emisor_String
Receptor_String
He visto en Internet un programa que me encantó, porque lo que hace es colocar un LED rojo y uno Verde en los pines 3 y 5 de Arduino y después
emite números entre 0 y 255 en el emisor mientras en el receptor corre un programa que controla que los números se reciban en el orden adecuado.
Cuando es así, ilumina brevemente la luz verde, en caso contrario la roja. Lo bueno de esto es que os sirve como ejemplo de si tenéis una buena
recepción o no, ya que según el baile de los LEDs tenéis una idea bastante aproximada de los errores de trasmisión que tenéis en vuestra zona.
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
Usad el programa Prog_79_1_Emisor para el emisor y este programa en el receptor Prog_79_4.
RESUMEN DE LA SESIÓN
Presentamos las unidades de radio NRF2401, que son ideales para muchos proyectos, porque son
buenas, bonitas y baratas.
Vimos como conectarlas a nuestros Arduinos con confianza usando el SPI y un par de pines.
Descargamos y usamos la librería RF24 para el manejo de las radios y vimos los comandos básicos para
enviar y recibir.
Anterior Siguiente
Reply
Reply
Reply
Reply
Reply
Reply
Reply
exit status 1
void value not ignored as it ought to be
// EMISOR
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
#include
#include
#include
#include
void setup()
{
//inicializamos el puerto serie
Serial.begin(9600);
//inicializamos el NRF24L01
radio.begin();// Basically turn on communications with the device
}
void loop()
{
//RECEPTOR
#include
#include
#include
#include
void setup()
{
//inicializamos el puerto serie
Serial.begin(9600);
//inicializamos el NRF24L01
radio.begin();
GIVE A REPLY
URL
Post comment
WordPress
WordPress Anti-Spam
Anti-Spam by
by WP-SpamShield
WP-SpamShield
Copyright Prometec
Home
Comunicación Dúplex Con NRF2401
OBJETIVOS
Presentar un par de programas sencillos que nos permitan usarlos en nuestros proyectos para enviar y
recibir órdenes o datos en ambas direcciones y en ambos módulos.
MATERIAL REQUERIDO.
ARDUINO
UNO REV 3 NRF24L01
Añadir al Añadir al
carrito carrito
CABLES
DUPONT
HEMBRA-
HEMBRA
Añadir al
carrito
En la sesión anterior establecimos una comunicación RF muy básica entre un emisor y un receptor de radio controlado con nuestros Arduinos.
Era un ejemplo muy sencillo, de hecho, procuramos que fuera la mínima expresión para facilitar la comprensión del ejemplo y para combatir el miedo
irracional que las comunicaciones de radio parece producir en muchos aficionados competentes.
Pero en realidad, gracias a ingenieros anónimos, como los que nos ofrecen las NRF24L01 , son muy fáciles de utilizar sin más que un pequeño
empujón de ayuda, algo que por cierto estaría bien que nos dieran los ejemplos que vienen con la librería (Que hace falta ser egiptólogo para
descifrarlos)
Y es una pena, porque estos modulitos cumplen la regla de las 3 Bs, Bueno, bonito y Barato y esto no es frecuente.
Por eso vamos a seguir incluyendo tutoriales de uso de estos módulos RF, y como no podía ser de otra manera, teníamos que ampliar el tutorial a un
ejemplo que hiciera comunicación bidireccional (Dúplex) de modo que un emisor envíe una secuencia de datos, que se reciben en un segundo nodo y
nos responde para saber que ha llegado el mensaje.
Pero antes de empezar con el ejemplo tenéis que saber que el módulo NRF24L01 es un transceptor y no un emisor receptor.
Un equipo emisor receptor puede enviar mensajes de radio y recibirlos simultáneamente porque ambos circuitos, aunque muy similares, están
aislados uno del otro y pueden operarse independientemente.
Estos equipos se venden y están disponibles en el mercado, ¿Pero sabéis que? Cuestan pasta. Por eso cuando alguien quiere ahorrar unos euritos en
la radio y dado que el emisor y el receptor son bastante similares, se monta un circuito con partes comunes . De este modo podemos emitir o
recibir ( Observad el uso de la disyuntiva no copulativa ) pero, y este es el truco, no a la vez.
No confundir con transponder o tranpondedor que es una cosa diferente. Aunque también es un sistema de
radio, el transponder emite una señal y espera una respuesta, que dependiendo de la que sea puede poner
o no en marcha una serie de acciones automáticas, como abrir la puerta de tu coche, o reclamar la
identificar un avión en vuelo con su posición.
Por eso nuestros módulos NRF2401, pueden estar en modo recepción o en modo emisión, pero no en ambos. Aunque eso sí, podemos cambiar de
uno a otro a voluntad, muy al estilo de las radios de aficionados que indican con un “corto” la intención de cambiar de modo.
Aunque ya vimos algunas en la pasada sesión, vamos a insistir con ellas. Lo primero es incluir algunas librerías:
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
Y después inicializamos los pines de control del módulo (Además, claro, de los de control SPI, de los que se encarga la librería):
RF24 radio(9,10);
En la última sesión dijimos que los pipes se pueden entender más o menos como canales de comunicación que no se interfieren unos con otros y
definimos uno para enviar nuestros mensajes.
Como lo que queremos ahora es generar una comunicación en ambos sentidos, vamos a necesitar dos canales o pipes, por el primero hablará uno y
escuchará el otro, y por el segundo funcionará al revés. Pero recordad que no podemos hacerlo a la vez.
Son un par de enteros de 64 bits y no os preocupéis mucho por ellos. Para iniciar la radio hacemos:
radio.begin();
Normalmente cuando envías un mensaje por radio, uno espera que llegue bien a la primera, pero la realidad suele tener su propia opinión y hacer de
las suyas. Por eso es buena idea que si no recibimos un mensaje correctamente, se reenvíe para garantizar la entrega.
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
El problema es cuantas veces hacemos este reenvío y cada cuanto tiempo. Por ese tenemos una instrucción como esta:
Hay una relación muy estrecha entre las señales de radio frecuencia, la electricidad y el electromagnetismo
y generalmente cuando se produce una, también aparecen las otras.
Hay cantidad de fenómenos naturales que generan señales de RF espurias, como tormentas y rayos o
tormentas solares incidiendo en las capas superiores de la atmosfera, pero también se generan por la
actividades humanas tales como arrancar cualquier cosa eléctrica, como motores o lámparas fluorescentes.
Hay todo un muestrario de fenómenos que te producirán interferencias RF, antes o después y es mejor
prevenirlo.
radio.setRetries(15,15);
Fija en el primer parámetro la pausa entre reintentos, en múltiplos de 250µS, por eso 0 son 250µS y 15 son 400µS.(La radio funciona a velocidad de
vértigo)
El segundo parámetro indica cuantos reintentos se deben hacer hasta dejarlo, con un máximo de 15.
Si bajamos estos valores, la velocidad de comunicación sube, pero también los errores y pueden perderse
datos. Por eso si la velocidad no es una cuestión decisiva (Y con Arduino rara vez lo será) es preferible
dejarlo en 15,15 y listo.
También te interesa saber que independientemente de la longitud del mensaje que tú quieras enviar, el módulo lo partirá en paquetes de una longitud
dada. Si no especificas un tamaño, el modulo usara 32 Bytes.
A esta longitud se le llama carga útil del paquete o PayLoad , y en caso de que haya un error en cualquiera de los bits de la transmisión, todo el
paquete debe ser reenviado de nuevo (Pero no te preocupes que el NRF2401 lo gestione en automático por ti).
Si tienes muchos errores de transmisión, puedes bajar este número para evitar reintentos, pero ten en
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
cuenta que el paquete conlleva una carga propia entre las radios y psi lo bajas mucho, puedes estar
enviando muchos más datos de control que de mensajes y esto es un desperdicio.
Por ultimo tendremos que abrir los canales de comunicación o pipes, uno para emitir y el otro para recibir
radio.openWritingPipe(pipes[0]);
radio.openReadingPipe(1,pipes[1]);
Montaremos de nuevo un par de Arduinos conectados mediante los NRF2401, con el mismo esquema que en la sesión anterior y que repito aquí
para vagos y gente con muchas cosas que hacer:
RF24 radio(9,10);
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
void setup(void)
{ pinMode(10, OUTPUT);
Serial.begin(9600);
radio.begin();
void loop(void)
{
radio.stopListening(); // Paramos la escucha para poder hablar
unsigned long time = millis();
Serial.print("Enviando ") ; Serial.println(time) ;
bool ok = radio.write( &time, sizeof(unsigned long) );
if (ok)
Serial.println("ok...");
else
Serial.println("failed");
Esperamos la confirmación de que han recibido el mensaje en destino, durante 200 ms. Y al salir comprobamos si se acabó el tiempo, o hemos
recibido un mensaje.
Si ha disparado el timeout imprimimos un mensaje de error, y en caso contrario procesamos el mensaje recibido.
if ( timeout )
Serial.println("Error, No ha habido respuesta a tiempo");
else
{ // Leemos el mensaje recibido
unsigned long got_time;
radio.read( &got_time, sizeof(unsigned long) );
Serial.print("Respuesta = ");
Serial.println(got_time);
}
delay(500);
Creo que no tendréis problemas con este programa. Vamos con el receptor Prog_79_B_receptor.
El setup es exactamente igual que en el emisor con una pequeña diferencia clave, los pipes de comunicación se invierten, ya que si el emisor
escucha por un canal, el receptor necesariamente tiene que hablar por él y viceversa, para que se puedan poner de acuerdo.
Por eso, el receptor empieza a escuchar en el setup y define los pipes de lectura y escritura invertidos con relación al emisor:
El resultado ha sido bastante pobre, ya que en cuanto colocas paredes de por medio la comunicaron se pierde con rapidez a partir de 10 metros, lo
que no resulta extraño dado que estoy usando módulos con antena integrada.
Normalmente a estos módulos se les asigna un alcance de 20 o 25 m sin obstáculos y esta distancia disminuye rápidamente a medidas que la señal
encuentra obstáculos, ya que la potencia de emisión es muy baja y por tanto, el resultado de la prueba concuerda con esta idea.
Si queremos ampliar el radio de cobertura tendremos que pasar a usar antenas amplificadas, similares a estas:
Estos módulos incluyen, no solo un adaptador de antena, además llevan integrado un amplificador de señal para potenciar la emisión y recepción
de señal, con lo que la distancia útil de transmisión crece hasta unos 100 metros (Según he visto en Internet ).
Por último y para cerrar esta sesión, comentar que también existe disponibles adaptadores USB con NRF2401 incluido, lo que nos permite enviar y
recibir mensajes desde nuestro PC a estos módulos.
De hecho tengo uno de un fabricante chino, pero me temo que Windows se niega tercamente a reconocerlo y la página del fabricante es un desastre
en el que soy incapaz de encontrar ningún driver para él.
Pero vale la pena comentar, que disponer de un medio de interactuar con estas radios desde nuestros portátiles es una utilidad que amplia
enormemente las posibilidades de comunicación y control de nuestros Arduinos.
Hemos visto más comandos disponibles en la librería que nos ayudaran a minimizar los problemas de
interferencias y reenvíos.
Escribimos unos programa básicos para comunicar dos de estos módulos y establecer un canal de ida y
vuelta
Anterior Siguiente
Copyright Prometec
void loop()
{
if (digitalRead(7) ) // Si hay dato valido
{ Serial.print("Valid trans. \t");
if (digitalRead(8))
Serial.print( "Boton A, pulsado");
if (digitalRead(9))
Serial.print( "Boton B, pulsado");
if (digitalRead(10))
{
Serial.print( "Boton C, pulsado");
digitalWrite (12, ! digitalRead(12)) ;
delay (500) ;
}
if (digitalRead(11))
{
Serial.print( "Boton D, pulsado");
digitalWrite (13, ! digitalRead(13)) ;
delay (500) ;
}
Serial.println("\t");
}
}
Anterior Siguiente
TIENDA ARDUINO RASPBERRY PI IMPRESORA 3D FORO CONTACTO
Home
Los Kits De Inicio Xbee
Como ya os comentaba unos días atrás, Digi International Spain tuvo la amabilidad de enviarme un par de kits de incio de XBee que voy revisando
con menos velocidad de lo que a mí me hubiera gustado, porque al final no voy sobrado de tiempo (Para nada, en serio ) pero con los que poco a
poco voy avanzando.
Me ha parecido interesante comentaros aquí la buena sensación que me ha causado tanto los kits como la magnífica documentación que DIGI pone
libremente a disposición de quien tenga interés, en su web.
Por eso es muy de agradecer los curso de formación que se pueden seguir en su
web (En seguida os digo donde impacientes ) y los kits de inicio que vende para
poder seguir esos cursos de modo que puedas arrancar en el sorprendente mundo
de las comunicaciones XBee, de un modo guiado y con garantías ( Esto me suena )
Para los que tengáis interés en echar una ojeada, y desde luego os lo recomiendo
si os interesa el tema, la página principal de entrada a la documentación y
tutoriales de Xbee es esta: http://docs.digi.com
Aquí encontrareis abundante documentación sobre lo que es XBee y los tipos de módulos disponibles, así como entradas a los cursos de formación
guiados. Tomarlo con calma porque hay una cantidad espectacular de información
En mi caso, me enviaron un par de kits de los que más directamente tienen que ver con Arduino:
Para los que no lo conozcáis, Processing es un lenguaje Open Source diseñado para artistas y creadores gráficos en principio que ha acabado
siendo, poco menos que el lenguaje oficial de Arduino, cuando buscas conectar tu Arduino y un PC para lo que sea (Ademas la comunidad Processing
y la de Arduino somos muy colegas de siempre)
El IDE de Arduino ha evolucionado como un fork del de Processing y si un día de esos que no sabéis que hacer, lo descargáis e instaláis, os
sorprenderá ver… que parece que estas en Arduino (En realidad es al revés)
https://docs.digi.com/display/XBeeArduinoCodingPlatform/Kit+contents
Ojo con una cosa, me ha pasado un par de veces que cuando entras te pierdes y no
encuentras por donde seguir, especialmente con el Chrome. Y es que tenéis un pulsador
disimulado en la pagina, que pone y quita el menú de la izquierda y para que no sea fácil, sale
quitado por defecto, así que seguramente tendréis que pulsarlo.
1 XBee Shield
1 2-axis joystick
6 Push-buttons
3 Solderless breadboards
18 LEDs
2 10kΩ potentiometers
2 9V Battery clips
2 9V Batteries
No es frecuente encontrar Kits tan bien provistos de material y empieza con un Arduino Leonardo para apoyar las prácticas e incluye todo lo
necesario, tal como un Shield XBee, para montar los módulos RF en nuestros Arduinos de un modo cómodo para conectar un par de
ellos rápidamente.
También trae unos adaptadores para protoboard para los módulos XBee, imprescindibles para algunas prácticas y tres módulos Xbee de la Serie 1.
Conviene decir aquí que XBee tienes varias líneas de producto, entre ellas la Serie 1, la más
PDF created on http://www.htm2pdf.co.uk via the HTML to PDF API
sencilla y con ciertas limitaciones, pero también la más sencilla de manejar y de iniciarse, para
después pasar a la Serie 2, no solo más potente sino también más versátil y después la Serie
2 PRO con alcances importantes .
No tendría sentido ponernos a hablar de todas las posibilidades que hay en Xbee ( Y yo no sería la persona más indicada ) porque el abanico de
posibilidades es inmenso y por eso, me parece un acierto un kit de inicio con la Serie 1, la más sencilla, pero que ya ilustra la forma de trabajar con
ella y descubre algunas posibilidades muy interesantes.
Me han gustado los tutoriales. Son claros y concisos y te van llevando por un itinerario bien pensado, para que veas posibilidades, mientras que en los
laterales tienes información adicional con la que extender lo que vas viendo, aunque rápidamente te pierdes porque el tema es inmenso.
Te muestra diferentes aspectos del tema Xbee, como la programación inicial de los módulos mediante el Xbee USB adapter y te presenta la
herramienta imprescindible para configurar los módulos Xbee: el XCTU
Varios ejemplos usan la librería Xbee para Arduino y te muestra muy por encima ( Porque aquí hay mucha tela que cortar ) ejemplos de comunicación
entre los Arduino mediante los módulos XBee usando la API de la librería.
Como no quiero enrollarme mucho, y para no ponerme pesado, el resumen es que me ha gustado el curso y que tengo que ir leyendo con calma la
inabordable cantidad de información que tenemos en la web de DIGI y que si os interesa en serio el tema de las comunicaciones inalámbricas
profesionales, tenéis aquí, un magnifico arranque de una forma ordenada.
Mientras que la plataforma Xbee Arduino está pensada para que los aficionados a Arduino, o sea los que estáis leyendo esto, se inicien en XBee
desde una plataforma en la que nos sentimos confortables, para los que se inician de cero sin experiencia en ningún micro controlador,
probablemente sea más interesante seguir el curso y kit que ahora nos ocupa, el “ Wireless connectivity kit ”
El contenido del kit es un poco menor que en del kit previo, pero puede también ser muy interesante para los que ya disponéis de Arduinos y
similares y queréis entrar directamente a conocer la plataforma XBee
2 XBee stickers
El contenido del curso, es tan magnifico e imprescindible como el anterior y desde luego os lo recomendaría tanto a los que dispongáis este kit como
a los que simplemente queréis husmear las posibilidades de conectividad de los XBee.
No dejéis de echarle un vistazo porque creo que si el tema de las comunicaciones inalámbricas os interesan, encontrareis rápidamente que XBee
puede no ser la solución más barata del mercado, pero es una que resuelve todas las posibilidades con un modelo común y una plataforma de
software que sorprende por su potencia en cualquier situación.
Anterior Siguiente
MFRC522::MIFARE_Key key;
byte nuidPICC[3];
Serial.begin(9600);
SPI.begin(); // Init SPI bus
rfid.PCD_Init(); // Init MFRC522
if ( ! rfid.PICC_IsNewCardPresent())
return;
if ( ! rfid.PICC_ReadCardSerial())
return;
rfid.PICC_HaltA();
rfid.PCD_StopCrypto1();
}
Anterior Siguiente