Interesante entrada en diverteka para empezar a programar en el mundillo de arduino (primeros pasos).
miércoles, 24 de diciembre de 2014
Arduino desde cero
viernes, 5 de diciembre de 2014
Modem 3G para nuestro Arduino
Gracias a este nuevo modem GSM desarrollado por MovilForum es posible permitir a una placa Arduino se conecte a Internet, realizar / recibir llamadas de voz y enviar / recibir mensajes SMS utilizando la red inalámbrica GPRS. Sólo tiene que conectarlo sobre una placa Arduino, conectar una tarjeta SIM de un operador que ofrezca cobertura GPRS y seguir unas sencillas instrucciones para empezar a controlar su mundo a través de internet.
Si deseas más información, puedes consultar la web de soloelectronicos.com o en arduino.cc
viernes, 26 de septiembre de 2014
Arduino y Atmel lanzan el nuevo Arduino Wi-Fi Shield 101
Arduino junto con Atmel han anunciado el Arduino Wi-Fi Shield 101 que permite el prototipado rápido para aplicaciones “Internet of things” integradas directamento a Arduino.
Entre las caracteristicas con las que cuenta este nuevo shield es que es compatible con Arduino Uno R3, la capacidad de desarrollar aplicaciones más seguras ya que cuenta con CryptoAuthentication device que permite a los usuarios incorporar fácilmente capacidad de autenticación de hardware en su diseño. Además cuenta con un chip Atmel que es parte de SmartConnect family.
Visto en hardwarehacking.mx
Visto en hardwarehacking.mx
sábado, 20 de septiembre de 2014
Módulo Wi-Fi para Arduino
Desde el blog Soloelectrónicos nos llega la noticia de un nuevo módulo denominado Wifi escudo 101 que se puede conectar a cualquier placa arduino moderna.
El escudo Wi-Fi para 101 es accionado por el controlador de red inalámbrica de Atmel, parte de la familia Atmel SmartConnect , y también incluye el dispositivo CryptoAuthentication que permite a los usuarios incorporar fácilmente capacidad de autenticación de hardware en su diseño.
martes, 8 de julio de 2014
Conferencia de David Cuartielles sobre Arduino en la CPMX5
En la pasada edición de la Campus Party México, David Cuartielles uno de los fundadores de la plataforma Arduino ha dado una interesante charla sobre la plataforma. También ha repasado los diferentes proyectos que se han realizado dando a conocer unas pocas de todas las posibilidades que ofrece la sencillez de la plataforma.
sábado, 31 de mayo de 2014
Open Curiosity - The First OpenSource Rover
OpenCuriosity es un proyecto español , resultado de más de 8 meses de trabajo de Carlos Sicilia Til, Luis Martín Nuez, Alejandro Gallego y Luis Frisón Alegre, fabricado tambien en Aragón (España) siendo uno de los 24 finalistas del famoso concurso de la NASA NASA Space Apps.
El prototipo lo constituye una maqueta a escala a 1:5 replica del famoso robot explorador de Marte basado en Arduino cuyo código fuente está en código abierto pretendiendo hacer accesible al gran publico la exploración del espacio.
Visto en soloelectronicos.com
domingo, 4 de mayo de 2014
Open Source Watch, un reloj impreso en 3D y con Arduino
Open Source Watch es un reloj inteligente fabricado con una impresora 3D y en su interior nos encontramos un Arduino. Es un proyecto abierto y que podremos construir por nuestra propia cuenta.
Jonathan Cook se presentó al concurso del medio Make con su propuesta: un reloj de muñeca con un display de blanco y negro en el que no sólo se muestra la hora y la fecha sino que también nos sirve para recibir notificaciones desde su smartphone: correo electrónico, redes sociales, mensajes de texto…
El resultado final es un reloj de muñeca algo rústico que dista del acabado de los modelos comerciales aunque precisamente esa no es la mayor preocupación. Funciona sin problemas y su creador pondrá a disposición de todo el mundo la documentación para que podamos fabricar uno por nuestra cuenta.
De momento en la página web oficial de Open Source Watch podéis ver el progreso de este reloj y empezar a montarlo. Aunque hay unos cuantos elementos fijos, por ejemplo podemos poner algunos personalizados a nuestro gusto como la pantalla. Jonathan ha optado por utilizar un OLED monocromático pero podemos usar otras más.
Visto en xataka.com
sábado, 3 de mayo de 2014
Software Tools for Makers: un Scada para Arduino
Software Tools for Makers es un Scada para Arduino dónde podremos monitorizar las entradas y salidas de la placa y crear un entorno de visualización de datos. Además, también puedes descargar un servidor para enviar y almacenar los datos.
El Software Tools for Makers está basado en el protocolo OPC (OLE for Process Control) que es un estándar de comunicación industrial.
Este software permite desarrollar proyectos industriales con Arduino, algo que cada día va cogiendo más fuerza.
Aquí el enlace a la página: http://www.st4makers.com/
Visto en diymakers.es
sábado, 26 de abril de 2014
Interrupciones en Arduino
Fuentes:
Las interrupciones son sucesos que pueden ocurrir en cualquier momento por lo que no podemos prever exactamente cuando detectarlas. Por ejemplo, podemos colocar un sensor en el frente de un vehículo para que detecte a distancia los posibles obstáculos que encuentre en su camino y lo informe a la tarjeta cambiando el estado de un Pin.
Arduino Uno tiene dos de los pines específicos, el Pin 2 y el Pin 3, capaces de detectar interrupciones en cualquier instante, independientemente de lo que en ese momento esté haciendo la función principal “loop”, Cuando Arduino detecta un cambio en el estado de uno de esos pines puede parar el funcionamiento del bucle “loop”donde se encuentre y lanzar una función asociada a esa interrupción inmediatamente, para continuar posteriormente el proceso del bucle “loop” desde donde lo parará.
¿Qué necesitamos para gestionar una interrupción?
volatile
En primer lugar definir previamente una variable del tipo “volatile” . Esta variable se caracteriza por que su valor pueda ser modificado por algo fuera de la sección del código en el que aparece, o sea en una función concurrente. asociadas a interrupciones, tambien llamadas rutina de servicio de interrupción (interrupt service routine).
La palabra clave “volatile” conocida como variable clasificada (qualifier), se utiliza delante de un tipo de datos, para modificar la forma en que se va a guardar el valor de la variable en el procesador. Una variable normal, una vez modificada por el programa en la memoria principal RAM, muy escasa y cara, se almacena en una dirección de memoria, mas abundante y barata ROM. Declarar un variable como “volatile” ordenamos al compilador que mantenga permanentemente presente el valor de la variable en la RAM y nos la suministre desde un registro de almacenamiento, ROM.
La sintaxis de “volatile” es: Volatile definición_de_variable
“volatile” indica que la variable que definimos a continuación la cambie siempre que se produzca una interrupción
attachInterrupt
En segundo lugar hay que informar a Arduino que utilizaremos la interrupción lo que hacemos como es habitual en función “setup” con la instrucción “attachInterrupt”. Este mandato especifica la función a invocar cuando se produce una interrupción externa. La mayoría de las placas Arduino tienen dos interrupciones externas: Las número 0 (en el pin digital 2) y la 1 (en el pin digital 3). Arduino Mega tiene otras cuatro: Las número 2 (pin 21), 3 (pin 20), 4 (pin 19) y 5 (pin 18).
La sintaxis de “attachInterrupt” es: attachInterrupt(nint, nfuncion, modo) donde:
“attachInterrupt” avisa a Arduino que vamos a utilizar interrupciones
“nint” número de interrupción. 0 si utilizamos el pin2, 1 si utilizamos el pin 3 “
“nfuncion” nombre de la función que invocamos.
“modo” es el acontecimiento que provoca la interrupción: Los acontecimientos contemplados son:
- LOW (bajo)dispara la interrupción cuando el pin pase a valor bajo (LOW).
- CHANGE (cambio) dispara la interrupción cuando el pin cambia de valor .
- RISING (aumentar) dispara la interrupción cuando el pin pasa de LOW a HIGH
- FALLING (caer) dispara la interrupción cuando el pin pasa de HIGH a LOW
interrupt service routine
Por último tendremos que definir lo que se hace cuando se dispara la interrupción, o sea la rutina de servicio de interrupción o en inglés interrupt service routine.
Esta rutina no admite ni parámetros de entrada ni devuelve nada pues los valores que pudiéramos pasarla a no ser de tipo volatile no están presentes en la memoria RAM del procesador cuando comienza inesperadamente su actuación y por otra parte no tendría sentido entregar parámetros que fuera a utilizar alguien fuera de esta función sin saber si van a existir o no. Por tanto debe ser del tipo void nfuncion () como lo son por ejemplo las funciones “setup” y “loop” que tampoco tienen parámetros ni devuelven nada.
También hay que tener al programarla que los mandatos relacionados con el transcurso del tiempo, no funcionan, pues el ordenador de forma virtual ha interrumpido precisamente el paso del tiempo para “congelar” la función “loop”. Por ello las interrupciones son esencialmente atemporales, y dentro de ellas no funcionan correctamente ni el mandato “delay” que para el programa durante el tiempo que se le indique, ni el mandato “millis” que devuelve el tiempo en milisigundos en que ha estado funcionando Arduino desde que arranco por última vez.
Tambien puede ocurrir y hay que tener en cuenta, que si se envían datos serie desde el exterior, por ejemplo del PC a Arduino, cuando se encuentra “ocupado” con una interrupción, pueden perderse, pues el ordenador está entonces volcado a hacer “otra cosa”, lo que mande hacer la interrupción.
Ejemplo:
int pin = 13;
volatile int estado = LOW;
void setup()
{
pinMode(pin, OUTPUT);
attachInterrupt(0, parpadeo, CHANGE);
}
void loop()
{
digitalWrite(pin, estado);
}
void parpadeo()
{
estado = !estado;
}
Otros comandos:
interrupts()
Descripción: Activa las interrupciones (después de haberlas desactivado con noInterrupts().
Parámetros: ninguno
Devuelve: no devuelve nada
noInterrupts()
Descripción: Desactiva las interrupciones (pueden reactivarse usando interrupts()).
Parámetros: ninguno
Devuelve: no devuelve nada
detachInterrupt(interrupt)
Descripción: Apaga la interrupción dada.
Parámetros: interrupt: el número de interrupción a invalidar (0 o 1).
Etiquetas:
Artículos,
Interrupciones
viernes, 18 de abril de 2014
Tamagochi arduino
Este Tamagotchi de escritorio dispone de todas las funciones que hicieron tan populares aquellos aparatos de los 90 y toma vida gracias al uso de una placa Arduino y una matriz de luces LED.
Si te gustaría hacer la tuya propia, puedes hacerlo siguiendo el tutorial.
Visto en gizmologia.com
Si te gustaría hacer la tuya propia, puedes hacerlo siguiendo el tutorial.
Visto en gizmologia.com
jueves, 17 de abril de 2014
Proyecto Arduino-Android: Temperatura y Humedad
En este proyecto, el objetivo es medir la temperatura y la humedad relatica utilizando arduino y mostrar los resultados en un dispositivo android.
Para medir la temperatura y la humedad relativa utilizo el módulo DHT-11 y para la conexión con el dispositivo Android utilizo el módulo HC-06
Para la programación de mi placa Arduino UNO utilizaré el IDE de Arduino y para programar el dispositivo android utilizaré App Inventor 2.
El esquema que voy a utilizar es el siguiente:
Nota: el módulo DHT11 que utilizo dispone únicamente de 3 pins, VCC-Data-GND.
Las conexiones son sencillas: Los pines de alimentación (VCC) de los módulos HC-06 y DHT-11 se conectan a los pines 3 y 7 de Arduino respectivamente. Los pines TxD y RxD del HC-06 se conectan a los pines 0 y 1 (RxD y TxT) de Arduino. El pin OUT del DHT-11 se conecta al pin 6 de Arduino
El código de Arduino es el siguiente:
//Añadimos la libreria con la cual trabaja nuestro sensor de temperatura/humedad
#include "DHT.h"
//Definimos el pin 3 de arduino para alimentar el módulo Bluetooth HC-06
#define PinVccHC06 3
//Definimos el pin 7 de arduino para alimentar el módulo de Temperatura DHT-11
#define PinVccDHT11 7
//Definimos el pin 6 de ardunino para conectar el pin OUT del módulo DHT
#define PinOutDHT 6
#define TypeDHT DHT11 //Definimos el tipo de sensor de temperatura
//Configura el pin con el que trabajamos y el tipo de sensor
DHT dht(PinOutDHT, TypeDHT);
float h,t; //variables de humedad y temperatura
char dato;
String readString;
void setup(){
//por defecto, el módulo HC-06 viene configurado 9600 N 8 1
Serial.begin(9600);
pinMode(13,OUTPUT);
pinMode(PinVccHC06,OUTPUT);
pinMode(PinVccDHT11,OUTPUT);
//Alimentamos el módulo HC-06 a 0v
digitalWrite(PinVccHC06,LOW);
//Alimentamos el módulo DHT-11 a 0v
digitalWrite(PinVccDHT11,LOW);
digitalWrite(13,HIGH);
delay(1000);
//Activa los sensores
digitalWrite(13,LOW);
//Alimentamos el módulo HC-06 a 5v
digitalWrite(PinVccHC06,HIGH);
//Alimentamos el módulo DHT-11 a 5v
digitalWrite(PinVccDHT11,HIGH);
delay(1000);
dht.begin(); //Inicializamos el módulo DHT
}
//Antes de ejecutar el programa, hay que vincular el dispositivo android con el módulo de bluetooth HC-06
//La clave por defecto del módulo HC-06 es 1234
void loop(){
//Comprobamos que los valores de t y h son´números. Si es un error enviamos un código de error
LeerDato();
if (readString.length() > 0){
if (readString == "Temp"){
EnviarTemperatura();}
if (readString == "Hum"){
EnviarHumedad();}
}
}
void LeerDato(){
readString ="";
while(Serial.available()) {
delay(10);
if (Serial.available() > 0) { //¿Hay datos en el buffer?
dato = Serial.read(); //Lee el dato
readString += dato; //Lo almacena en readString
}
}
}
void EnviarTemperatura(){
t = dht.readTemperature(); //Lee la temperatura
if (isnan(t)){ //Comprueba que el dato es un número
Serial.print("Error");
} else {
Serial.print(t); //Envía el dato por el puerto serie
}
}
void EnviarHumedad()
{
h = dht.readHumidity(); //Lee la humedad
if (isnan(h)){ //Comprueba que el dato es un número
Serial.print("Error");
} else {
Serial.print(h); //Envía el dato por el puerto serie
}
}
De forma resumida, el programa realiza las siguientes tareas:
- Carga la librería para programar el sensor de temperatura.
- Define en que pins y que modelo de sensor de temperatura vamos a utilizar
- En setup inicializamos tanto el puerto serie que se comunicará con el sensor bluetooth como el sensor de temperatura. Además, alimentamos ambos módulos.
- En loop básicamente llamamos al procedimiento de leer un dato por el puerto serie. Si la lectura es correcta comprobamos si nos solicitan la temperatura o la humedad, realizamos la medición y enviamos el dato por el puerto serie.
El diseño de la aplicación es el siguiente:
El código utilizado es el siguiente:
Variables utilizadas:
Nota: MAC es la dirección de mi módulo bluetooth
Inicializamos:
Conexión Bluettooth:
Lectura de los datos (TimeInterval clock 1 : 1000):
La parte más complicada de entender es seguramente la lectura de los datos. Utilizo la variable Enviar para saber cuando debo enviar la orden de lectura de la temperatura o la humedad y cuando debo esperar a recibir la lectura de dichos datos enviada por la placa arduino. Por otra parte, la variable T la utilizo para alternar la lectura de la temperatura y de la humedad.
Recepción del Texto enviado por Arduino:
Desconexión del módulo Bluetooth:
Salir y cerrar el programa:
Para más información sobre programación en app inventor puedes consultar mi blog appinventoramuete. En la entrada Cliente Bluetooth podrás aprender a utilizar este componente.
Descargas:
martes, 15 de abril de 2014
El puerto serie y Arduino
Fuentes:
Comunicación Serial
Arduino posee como principal característica la habilidad de comunicarse con nuestra computadora a través del puerto serie. Esto se conoce como comunicación serial. Debido a que el uso de este puerto ha quedado un poco en desuso a favor de la tecnología USB, Arduino cuenta con un convertidor de Serial a USB que permite a nuestra placa ser reconocida por nuestra computadora como un dispositivo conectado a un puerto COM aún cuando la conexión física sea mediante USB.
Arduino IDE nos proporciona una herramienta que nos permite enviar y visualizar los datos que se manejan a través del puerto Serie. Dicha herramienta se conoce como Monitor Serial y se puede encontrar en el menú de herramientas, en la opción “Monitor Serial”. Es la forma más simple que existe para establecer la comunicación serial con Arduino.
A través de esta ventana se puede enviar o recibir información utilizando el puerto serie. Nótese que para poder abrir esta ventana es necesario que tengamos nuestra placa Arduino conectada a nuestra PC mediante USB.
Para iniciar la comunicación serial con Arduino utilizando el Monitor Serial debemos establecer algunos comandos en el Arduino IDE y luego subirlos al microcontrolador.
Comandos:El código es el siguiente:
Serial.begin(9600); En la función Setup inicializamos la comunicación serial. El 9600 indica el baud rate, o la cantidad de baudios por segundo que manejará el puerto serie. Se define baudio como una unidad de medida, usada en telecomunicaciones, que representa el número de símbolos por segundo en un medio de transmisión analógico. Para nuestros propósitos utilizaremos comúnmente el número 9600 aunque puede utilizar estas velocidades: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200. Sin embargo, puedes especificar otras velocidades - por ejemplo, para comunicarte a través de los pines 0 y 1 con un componente que requiere una velocidad de transmisión en particular.
Serial.println('caracteres'); Cuando usamos println le estamos diciendo al microcontrolador que tendrá que imprimir un caracter a través del puero serie. Hay otros métodos como Serial.print o Serial.write que nos sirven para imprimir o escribir en el puerto serie, sin embargo la función println agrega un salto de línea cada vez que se envía un dato, lo que es provechoso para nosotros en algunos casos, especialmente cuando utilizamos el monitor serial. En la función println se debe establecer lo que se quiere imprimir entre paréntesis y con comillas. En este caso vamos a imprimir el caracter ’1′. Mediante la sintaxis Serial.println(val, format) se puede especificar el número de la base (para números enteros) (por ejemplo DEC) o el número de posiciones decimales (para números de coma flotante o tipo "float")
if (Serial.available()>0){...} Cuando halla datos disponibles para leer en el puerto serie, el método Serial.available() tendrá un número mayor a cero (>0) por lo que cumplirá con la condición establecida en la estructura selectiva y el programa procederá a ejecutar los comandos que estén dentro de las llaves ({}) del if. De forma general, esta función devuelve el número de bytes (caracteres) disponibles para ser leídos por el puerto serie. Se refiere a datos ya recibidos y disponibles en el buffer de recepción del puerto (que tiene una capacidad de 128 bytes).
Serial.write(); Escribe datos binarios en el puerto serie. Estos datos se envían como un byte o una serie de bytes; para enviar los caracteres que representan los dígitos de un número usar funcion print() en su lugar.
Sintaxis:
- Serial.write(val); val: un valor para enviar como un solo byte
- Serial.write(str); str: una cadena 'string' para enviar como una serie de bytes
- Serial.write(buf, len); buf: un 'array' para enviar como una serie de bytes y len: longitud del búfer
input=Serial.read(); Cuando entre en la estructura selectiva, a la variable input (al principio del código se declara una variable tipo int llamada input) se le asignará un valor que se lea desde el puerto serie mediante el método Serial.read(). Siempre que necesitamos leer algo lo hacemos mediante este método (devuelve -1 si no hay datos disponibles).
Nota: Cuando se intenta imprimir un entero (1,2,3,4,5…), el método Serial.println() imprimirá dicho entero en formato ASCII.
Serial.end(); Desactiva la comunicación serie, permitiendo a los pines RX and TX ser usados como entradas o salidas digitales.
Serial.flush(); Vacía el búfer de entrada de datos en serie. Es decir, cualquier llamada a Serial.read () o Serial.available () devolverá sólo los datos recibidos después la llamada más reciente a Serial.flush ().
Conectado el puerto serie con el exterior
Arduino dispone de un puerto serie que, en la placa Arduino UNO, está localizado en los pins 0 y 1 (Rx, Tx).
Nota: La placa Arduino Mega tiene tres puertos adicionales de serie: Serial1 en los pines 19 (RX) y 18 (TX), Serial2 en los pines 17 (RX) y 16 (TX), Serial3 en los pines 15 (RX) y 14 (TX).
Podemos utilizar otros pines de Arduino para la transmisión serie si añadimos al programa la la librería “SoftwareSerial.h” que viene incluida en el IDE de Arduino. Con esta librería podremos usar, por ejemplo, los pines 2 y 3 como RX y TX. Al ser un puerto "software" la velocidad máxima que se puede utilizar es de 9.600 bps
Podemos utilizar otros pines de Arduino para la transmisión serie si añadimos al programa la la librería “SoftwareSerial.h” que viene incluida en el IDE de Arduino. Con esta librería podremos usar, por ejemplo, los pines 2 y 3 como RX y TX. Al ser un puerto "software" la velocidad máxima que se puede utilizar es de 9.600 bps
Ejemplo:
#include "SoftwareSerial.h"
SoftwareSerial blue(2, 3);
int pot=0;
void setup(){
blue.begin(9600);
blue.println("Conectado");
}
void loop(){
pot=analogRead(0);
blue.println(pot);
delay(1000);
}
Nota: Actualmente, en realidad, se suele usar una extensión del código ASCII (llamada Unicode) que permita el uso de caracteres no incluidos en la tabla original, y que permita representar caracteres como las Ñ, o acentos para el español, pero también alfabetos distintos como el Kanji chino o el alfabeto cirílico. Y este es el motivo por el que podéis leer las letras chinas o rusas en las páginas de internet de estos países.
Para mostrar por ejemplo la o acentudad ó habría que utilizar:
Serial.println(char(243));
Módulo de Bluetooth HC-06
Fuente: diymakers.es
El Bluetooth es un estándar de comunicación inalámbrica que permite la transmisión de datos a través de radiofrecuencia en la banda de 2,4 GHz. Existen muchos módulos Bluetooth para usarlos en nuestros proyectos de electrónica, pero los más utilizados son los módulos de JY-MCU, ya que son muy económicos y fáciles de encontrar en el mercado. Son módulos pequeños y con un consumo muy bajo que nos permitirán agregar funcionalidades Bluetooth a nuestro Arduino. Estos módulos contienen el chip con una placa de desarrollo con los pins necesarios para la comunicación serie.
Comandos AT
Los parámetros por defecto del módulo HC-06 son los siguientes:
El Bluetooth es un estándar de comunicación inalámbrica que permite la transmisión de datos a través de radiofrecuencia en la banda de 2,4 GHz. Existen muchos módulos Bluetooth para usarlos en nuestros proyectos de electrónica, pero los más utilizados son los módulos de JY-MCU, ya que son muy económicos y fáciles de encontrar en el mercado. Son módulos pequeños y con un consumo muy bajo que nos permitirán agregar funcionalidades Bluetooth a nuestro Arduino. Estos módulos contienen el chip con una placa de desarrollo con los pins necesarios para la comunicación serie.
Existen dos modelos de módulos Bluetooth: el HC-05 que puede ser maestro/esclavo (master/slave), y el HC-06 que solo puede actuar como esclavo (slave). La diferencia entre maestro y esclavo es que en modo esclavo es el dispositivo quien se conecta al módulo, mientras que en modo maestro es el módulo quien se conecta con un dispositivo.
Físicamente, los dos módulos son muy parecidos, solo varían algunas conexiones. Los pins del módulo HC-06 son los siguientes:
- Vcc: Alimentación del módulo entre 3,6V y 6V.
- GND: La masa del módulo.
- TXD: Transmisión de datos.
- RXD: Recepción de datos (Precaución: Algunos módulos no permiten en su pin RX mas de 3.3v. En mi caso, he adquirido un módulo que admite hasta 5 v.)
Los comandos AT son un tipo de comandos que sirven para configurar el módulo Bluetooth a través de un microcontrolador, un ordenador o con cualquier dispositivo que posea una comunicación serie (Tx/Rx). Son unas instrucciones que nos permiten cambiar los baudios del módulo, el PIN, el nombre, etc. Para usar los comandos AT el módulo Bluetooth no debe estar vinculado a ningún dispositivo (led rojo del módulo parpadeando). Según las especificaciones del módulo, el tiempo que se tiene que respetar entre el envío de un comando AT y otro tiene que ser de 1 segundo. Si se envía un comando AT y en menos de un segundo se envía otro, el módulo no devuelve respuesta.
- Baud rate: 9.600 N 8 1
- ID: Linvor
- Password: 1234
Lo normal es conectar el módulo HC-06 a los pines del Arduino 0 y 1 (RX y TX) y establecer una conexión serie:
Serial.begin(9600);
Luego, utilizaremos los métodos estándar para trabajar con el puerto serie (ver el siguiente enlace)
Suscribirse a:
Entradas (Atom)