comunicaciones digitales con arduino. · ejemplos de este tipo de comunicación son: i2c one wire...

Interfaces y Periféricos. Guía 5. 1

Comunicaciones digitales con

Arduino.

Describir las comunicaciones electrónicas y su programación en Arduino.

Conectar un dispositivo con bluetooth con Arduino para manejo remoto.

Comunicar datos desde Arduino a computadora con protocolo RS-232.

Comunicar datos entre tarjetas Arduino utilizando protocolo I2C.

1 Computadora con sistema operativo Linux o Windows y con el programa Arduino IDE

instalado.

1 Cable USB (tipo A hacia tipo B).

1 Tarjeta Arduino UNO R2 o R3.

1 Módulo MAX232 para comunicación con computadora

1 Cable serial plano.

2 Resistencias de 4.7kΩ.

1 Potenciómetro de 10kΩ.

1 tarjeta I/O.

1 Breadboard.

1 Pinza punta plana.

1 Cortadora (pinza de corte diagonal).

Cables UTP.

Debido a que Arduino UNO R3 tiene un microcontrolador ATMEGA 328 como núcleo

principal, posee diversas formas de comunicarse con el exterior, permitiendo a una

computadora utilizar esta interfaz para escribir y leer datos de dispositivos ya no de forma

paralela, sino serial, empleando una, dos o tres líneas enviar y recibir datos por tramas a

sensores de temperatura que entregan su valor con protocolo RS-232, SPI, I2C, One Wire,

etc.

A continuación se describen algunas de las características de los protocolos de comunicación

digital:

El puerto serial de las computadoras es conocido como puerto RS-232, la ventaja de este

puerto es que todas las computadoras traen al menos un puerto serial, este permite las

comunicaciones entre otros dispositivos tales como otra computadora, el mouse, impresora

y para nuestro caso con los microcontroladores.

Objetivos Específicos.

Materiales y equipos.

Facultad: Ingeniería

Escuela: Electrónica

Asignatura: Interfaces y Periféricos (IYP111).

Lugar de Ejecución: Microprocesadores (3.23).

Introducción Teórica.

2 Interfaces y Periféricos. Guía 5.

Existen dos formas de intercambiar información binaria: comunicación paralela y serie.

La comunicación paralela transmite todos los bits de un dato de manera simultánea, por lo

tanto la velocidad de transferencia es rápida, sin embargo tiene la desventaja de utilizar una

gran cantidad de líneas, por lo tanto se vuelve más costoso y tiene la desventaja de atenuarse

a grandes distancias, por la capacitancia entre conductores así como sus parámetros

distribuidos.

Tipos de Comunicaciones Seriales:

La Existen dos tipos de comunicaciones seriales: la síncrona y asíncrona.

En la comunicación serial síncrona además de una línea sobre la cual se transmitirán los datos

se necesita de una línea que lleve los pulsos de reloj que indicarán cuando un dato es válido

o está en sincronía.

Ejemplos de este tipo de comunicación son:

I2C

ONE WIRE

SPI

En la comunicación serial asíncrona, no son necesarios los pulsos de reloj. La duración de

cada bit está determinada por la velocidad con la cual se realiza la transferencia de datos. La

siguiente figura muestra la estructura de una carácter que se transmite en forma serial

asíncrona.

Figura 1. Esquema de trama de comunicación serial asíncrona.

Normalmente cuando no se realiza ninguna transferencia de datos, la línea del transmisor se

encuentra en estado de espera (idle) este quiere decir en estado alto. Para iniciar la

transmisión de datos, el transmisor coloca esta línea en bajo durante determinado tiempo, lo

cual se le conoce como bit de arranque (start bit) y a continuación empieza a transmitir con

un intervalo de tiempo los bits correspondientes al dato, empezando siempre por el BIT

menos significativo (LSB), y terminando con el BIT más significativo. Si el receptor no está

sincronizado con el transmisor, este desconoce cuándo se van a recibir los datos. Por lo tanto

el transmisor y el receptor deberán tener los mismos parámetros de velocidad, paridad,

número de bits del dato transmitido y de BIT de parada.

En los circuitos digitales, cuyas distancias son relativamente cortas, se pueden manejar

transmisiones en niveles lógicos TTL (0-5V), pero cuando las distancias aumentan, estas


señales tienden a distorsionarse debido al efecto capacitivo de los conductores y su resistencia

eléctrica. El efecto se incrementa a medida que se incrementa la velocidad de la transmisión.

Todo esto origina que los datos recibidos no sean igual a los datos transmitidos, por lo que

no se puede permitir la transferencia de datos. Una de las soluciones más lógica es aumentar

los márgenes de voltaje con que se transmiten los datos, de tal manera que las perturbaciones

a causa de la línea se pueden corregir.

La Norma RS-232

Ante la gran variedad de equipos, sistemas y protocolos que existen surgió la necesidad de

un acuerdo que permitiera a los equipos de varios fabricantes comunicarse entre sí. La EIA

(Electronics Industry Association) elaboró la norma RS-232, la cual define la interfaz

mecánica, los pines, las señales y los protocolos que debe cumplir la comunicación serial.

Todas las normas RS-232 cumplen con los siguientes niveles de voltaje:

Un “1” lógico es un voltaje comprendido entre –5v y –15v en el transmisor y entre -3v y

–25v en el receptor.

Un “0” lógico es un voltaje comprendido entre +5v y +15v en el trasmisor y entre +3v y

+25v en el receptor.

El envío de niveles lógicos (bits) a través de cables o líneas de transmisión necesita la

conversión a voltajes apropiados. En los microcontroladores para representar un 0 lógico se

trabaja con voltajes inferiores a 0.8v, y para un 1 lógico con voltajes mayores a 2.0V. En

general cuando se trabaja con familias TTL y CMOS se asume que un “0” lógico es igual a

cero Volts y un “1” lógico es igual a cinco Volts. La importancia de conocer esta norma,

radica en los niveles de voltaje que maneja el puerto serial del ordenador, ya que son

diferentes a los que utilizan los microcontroladores y los demás circuitos integrados. Por lo

tanto se necesita de una interfaz que haga posible la conversión de niveles de voltaje a los

estándares manejados por los CI TTL.

El Circuito MAX-232

Este circuito soluciona los problemas de niveles de voltaje cuando se requiere enviar unas

señales digitales sobre una línea RS-232. Este chip se utiliza en aquellas aplicaciones donde

no se dispone de fuentes dobles de +12 y –12 Volts. El MAX 232 necesita solamente una

fuente de +5V para su operación, internamente tiene un elevador de voltaje que convierte el

voltaje de +5V al de doble polaridad de +12V y –12V. Cabe mencionar que existen una gran

variedad de CI que cumplen con la norma RS-232 como lo son: MAX220, DS14C232,

MAX233, LT1180A.

Comunicaciones síncronas:

Un circuito inter-integrado (I²C, del inglés Inter-Integrated Circuit) es un bus serie de datos

desarrollado en 1982 por Philips Semiconductors (hoy NXP Semiconductors). Se utiliza

principalmente internamente para la comunicación entre diferentes partes de un circuito, por

ejemplo, entre un controlador y circuitos periféricos integrados.


El sistema original fue desarrollado por Philips a principios de 1980 con el fin de controlar

varios chips en televisores. Desde mediados de 1990 el I²C también es utilizado por algunos

competidores para designar los sistemas compatibles I²C Philips, incluyendo Siemens AG

(posteriormente Infineon Technologies AG), NEC, STMicroelectronics, Motorola (Freescale

más adelante), Intersil, etc. Hay un total de mil circuitos integrados diferentes de más de 50

fabricantes (según datos de 2014).

Figura 2. Ejemplo de conexión en protocolo I2C.

Protocolo de dos hilos de control, uno para transmitir los datos (SDA) y el reloj asíncrono

(SCL) que indica cuando leer los datos. Más GND y 5V (cuando se requiera).

Cada dispositivo conectado al bus I2C y cada uno tiene su dirección exclusiva, de 7 bits,

(Asi que, en teoría, podemos conectar 27 = 128, dispositivos).

Uno de estos componentes, debe actuar como master, es decir controla el reloj.

No se requiere una velocidad de reloj estricta, ya que es el master quien controla el Clock.

Es multi master, el master puede cambiar, pero solo uno puede estar activo a la vez, y

proporciona un protocolo de arbitraje y detección de colisiones.

Atmel introdujo por motivos de licencia la designación TWI (interfaz de dos hilos)

actualmente utilizada por algunos otros fabricantes. Desde el punto de vista técnico,

TWI e I²C son idénticos. Sin embargo, el 1 de octubre 2006, la patente original caducó,

así que ya no hay derechos de autor para el uso del término I²C.

Parte 1: Comunicación serial asíncrona por puerto RS232 de la computadora con

Arduino.

1. Encienda la computadora. Cuando cargue el sistema operativo utilice las siguientes

credenciales:

Usuario: usuario0

Contraseña: usuario

Procedimiento.


2. Abra el Arduino IDE y vaya al menú Archivo > Ejemplos > SoftwareSerial y abra el

SoftwareSerialExample que tiene el siguiente código:

/* Software serial multple serial test

Receives from the hardware serial, sends to software serial.

Receives from software serial, sends to hardware serial.

The circuit:

* RX is digital pin 3 (connect to TX of other device)

* TX is digital pin 2 (connect to RX of other device)

Note:

Not all pins on the Mega and Mega 2560 support change interrupts, so only the

following

can be used for RX:

10, 11, 12, 13, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 68, 69

Not all pins on the Leonardo support change interrupts, so only the following can be

used for RX:

8, 9, 10, 11, 14 (MISO), 15 (SCK), 16 (MOSI).

created back in the mists of time

modified 25 May 2012 by Tom Igoe based on Mikal Hart's example

This example code is in the public domain.

*/

#include <SoftwareSerial.h>

SoftwareSerial mySerial(3,2); // RX, TX

void setup()

// Open serial communications and wait for port to open:

Serial.begin(9600);

while (!Serial)

; // wait for serial port to connect. Needed for native USB port only

Serial.println("Goodnight moon!");

// set the data rate for the SoftwareSerial port

mySerial.begin(9600);

mySerial.println("Hello, world?");

void loop() // run over and over

if (mySerial.available())

Serial.write(mySerial.read());

if (Serial.available())

mySerial.write(Serial.read());

Código 1. Código del ejemplo SoftwareSerialExample

3. Analice el código presentado y proceda a armar el circuito sugerido para la prueba de

transmisión de datos entre la computadora y Arduino, ver Figura 3.

4. Observe que hay 2 conexiones seriales, ambas a 9600 baudios, descargue el sketch del

código 1 a Arduino y abra el monitor serial del Arduino IDE.


Figura 3. Conexión a puerto serie con módulo MAX232 a Arduino.

Figura 4. Circuito esquemático de tarjeta de comunicación serie con módulo MAX232.

5. Al abrir el monitor serial de Arduino IDE, configure la velocidad de transmisión a 9600

baudios como se muestra en la siguiente Figura:


Figura 5. Monitor serial con velocidad a 9600 baudios.

6. Observe que al abrir el monitor serial y configurar correctamente la velocidad aparecen

las palabras “Goodnight moon”. Ahora es necesario configurar una manera de ver los

datos que aparecen en el otro puerto serie que es el de la computadora.

Windows:

Presione la tecla inicio en su teclado (símbolo ) y digite Gtkterm.

Ubuntu (Linux):

Dé clic izquierdo en el primer icono (Buscar en el equipo ) de la barra lateral

izquierda y digite Gtkterm o UXterm.

7. Aparecerá una ventana negra, la cual es el programa para transferencias serie, por defecto

está configurado como 9600 baudios, 8 bits, Sin paridad, y 1 bit de paro, vaya con el

mouse a la parte superior de la pantalla, aparecerá la barra de menús en ella seleccione

Configuration >> Port y luego presione Ok.

Figura 6. Configuración de la velocidad a 9600 baudios en programa Gtkterm.

8. Seleccione en la barra de menús:

Configuration >> Local Echo

Configuration >> CR LF auto


9. Reinicie el Arduino Uno, puede pulsar el botón de Reset o desconectar el cable USB y

volver a conectarlo.

10. En el monitor serial de Arduino IDE se presenta el mensaje Goodnight moon y en el

GTKterm deberá aparecer el mensaje Hello World? Ponga las dos ventanas a la par una

de la otra, la del Gtkterm y la del monitor serial de Arduino IDE de forma visible, para

poder observar la transmisión del texto de una ventana hacia la otra.

11. Escriba la palabra hola en el monitor serial de Arduino IDE, dé clic en enviar y observe

qué sucede en la ventana de GTKterm.

12. Escriba en la ventana de GTKterm, observe cómo el texto digitado aparece en la pantalla

del monitor serial de Arduino IDE.

Desafíos cortos:

Basándose en el ejemplo transmita desde Arduino a la computadora un texto de 20

caracteres, se sugiere el uso de arreglos para ir enviando uno a uno los caracteres. Haga

el arreglo con caracteres tomados del teclado, guárdelo en memoria y luego envíelo.

Basándose en el ejemplo del monitor serial de Arduino IDE, transmita el valor de una

variable analógica cada segundo al puerto serie de la computadora.

Parte 2. Comunicaciones serial síncrona – I2C.

13. Arme el circuito de la siguiente figura con los compañeros de la mesa más cercana:

Figura 7. Conexión de dos Arduinos para comunicación I2C.

14. Descargue el siguiente sketch para el maestro I2C (mesa 1).


//Arduino uno - Master

#include <Wire.h>

#define I2C_ADDR 0x08

int inByte = 0; // Byte de entrada serial

int c=0;

char c2;

void setup()

Wire.begin(); // Habilita bus I2C

// (Dirección es opcional para el maestro)

Serial.begin(9600); // Inicia comunicación serial

Serial.println("******************************");

Serial.println("Prueba bus I2C (Maestro)"); //Imprime un mensaje en el monitor.

Serial.println("******************************");

Serial.println("El dato enviado por el esclavo es: ");

void loop()

while (Serial.available() > 0)

inByte = Serial.read();

Wire.beginTransmission(I2C_ADDR); // transmite a dirección #8

Wire.write(inByte); // Envía un byte

Wire.endTransmission(); // Detiene la transmisión

Wire.requestFrom(I2C_ADDR, 1); //request 1 bytes from slave device #8

while (Wire.available()) //slave may send less than requested

c = Wire.read(); //receive a byte as character

c2 = (char)c;

if (c2>9 & c2<=127)

Serial.print(c2); //print the character

delay(10);

Código 2. Código para maestro I2C.

15. Descargue el siguiente sketch para el esclavo I2C (mesa 2).

//Arduino uno - Esclavo

#include <Wire.h>

#define I2C_ADDR 0x08

int inByte;

int c=0;

char c2;

void setup()

Wire.begin(I2C_ADDR); //Se une al bus I2C con dirección 0x08

Wire.onRequest(requestEvent); //Registra un evento - función para escribir

Wire.onReceive(receiveEvent); //Registra un evento - función para leer

Serial.begin(9600);

Serial.println("******************************");

Serial.println("Prueba bus I2C (Esclavo)"); //Imprime un mensaje en el monitor.

Serial.println("******************************");

Serial.println("El dato enviado por el maestro es: ");


void loop()

//Estas funciones se ejecutan cuando se recibe un dato del maestro

//se registran como evento, ver void setup()

void receiveEvent(int howMany) // Función para recibir datos

while (Wire.available()) //Bucle para la comunicación serie

c = Wire.read(); //Recibe el byte como entero

c2 = (char)c;

Serial.print(c2); //Imprime el caracter en el monitor serial

void requestEvent() // Función para enviar datos

if (Serial.available() > 0)

inByte = Serial.read();

Wire.write(inByte);

Código 3. Código para esclavo I2C.

16. Compruebe con los respectivos monitores seriales de Arduino IDE en cada computadora

que se realiza correctamente la transferencia de datos. Coloque el retorno de carro y nueva

línea en ambas ventanas del monitor serial.

Figura 8. Ventana del monitor serial de Arduino IDE.

Desafíos cortos:

Transfiera una cadena del maestro al esclavo en forma de arreglo (array) de al menos 20

caracteres.

Cree 8 caracteres para pantallas lcd, como los mostrados en la fila superior de la Figura

8, conecte al pin A0 un potenciómetro en el lado del esclavo y desde el maestro haga la

solicitud de la lectura analógica, cada 0.5 segundos, de acuerdo al valor medido será la

cantidad de cuadros que deberán llenarse por carácter en la segunda fila, tal como se hace

en el ejemplo mostrado en la fila inferior, es decir 0 debería mostrar toda la fila dos

apagada y 1023 toda la fila llena con el carácter 8 creado. Los cuadros mostrados en la


fila superior no deben aparecer allí solo son representativos para explicar cuáles

caracteres deben crearse.

Figura 9. Ejemplo de llenado de acuerdo a la lectura analógica realizada por el esclavo I2C.

Envío de valores enteros de 16 bits a través de SCI:

17. Arme el circuito de la figura 10, con los compañeros de la mesa más cercana.

Figura 10. Comunicación I2C, transferencia de datos de más de 8 bits.

18. Descargue el siguiente sketch para el maestro I2C (mesa 1) posee escritura en puerto

serial (Arduino IDE) y en tarjeta I/O.

//Arduino uno - Master

#include <Wire.h>

#define I2C_ADDR_2 0x12

int salidas[]=2,3,4,5,6,7,8,9;

int i=0;

int ix=0;

int inByte = 0; // Byte de entrada serial

int c=0;

int c2=0;

int Valor=0;

Esclavo I2C Maestro I2C


float reading;

float Volt=0;

int retardo = 2000;

int Valorbit=0;

int temp=0;

void setup()

for(i=0;i<8;i++)

pinMode(salidas[i],OUTPUT);

Wire.begin(); // Habilita bus I2C

// (Dirección es opcional para el maestro)

Serial.begin(9600); // Inicia comunicación serial

Serial.println("******************************");

Serial.println("Prueba bus I2C (Maestro)"); //Imprime un mensaje en la LCD.

Serial.println("******************************");

Serial.println("El dato enviado por el esclavo es: ");

void loop()

Valor = (c*256) + c2;

reading = float(Valor);

Volt = 5 * (reading/1023);

Serial.println("*************************************");

Serial.print("Vin (Dec): ");

Serial.println(Volt);

Serial.print("A0 (Dec): ");

Serial.println(Valor, DEC);

Serial.print("A0 (Bin): ");

Serial.println(Valor, BIN);

Serial.print("A0 (HIGH) => Valor * 256: ");

Serial.println(c, DEC);

Serial.print("A0 (LOW): ");

Serial.println(c2, DEC);

Wire.requestFrom(I2C_ADDR_2, 2); //request 2 bytes from slave device #8

while (Wire.available()) //slave may send less than requested

c = Wire.read();

c2 = Wire.read();

delay(10);

Escribe(c);

delay(retardo);

Escribe(c2);

delay(retardo);

void Escribe(int conteo)

temp=conteo;

for(ix=0;ix<8;ix++)

Valorbit=temp%2;

temp=temp/2;

if(Valorbit==0)

digitalWrite(salidas[ix],LOW);

else

digitalWrite(salidas[ix],HIGH);

Código 4. Código para maestro I2C.


19. Descargue el siguiente sketch para el esclavo I2C (mesa 2) posee entrada análoga A0

conectada a un potenciómetro.

//Arduino uno - Esclavo1

#include <Wire.h>

#define I2C_ADDR_2 0x12

int inByte;

int c = 0;

char c2;

//Dato = 1000 (Dec) => 3 E 8

//Dato = 1000 (Dec) => 1 1 1 1 1 0 1 0 0 0 (BIN)

//Dato = 1000 (Dec) => 512 + 256 + 128 + 64 + 32 + 0 + 8 + 4 + 2 + 0

//Dato = 1000 (Dec) => 768 + 192 + 40

//Dato = 1000 (Dec) => 960 + 40

int Pin = A0;

float reading;

float Volt = 0;

int Valor = 0;

int Var_low = 0; //Parte alta

int Var_high = 0; //Parte baja

void setup()

Wire.begin(I2C_ADDR_2); //Se une al bus I2C con dirección 0x12

Wire.onRequest(requestEvent); //Registra un evento - función para escribir

//analogReference(INTERNAL);

Serial.begin(9600);

Serial.println("******************************");

Serial.println("Prueba bus I2C (Esclavo)"); //Imprime un mensaje en la LCD.

Serial.println("******************************");

Serial.println("El dato enviado por el maestro es: ");

void loop()

reading = analogRead(Pin);

Valor = int(reading);

Volt = 5 * (reading / 1023);

Valor = Valor & 0x03FF;

Var_high = (int)highByte(Valor);

Var_low = (int)lowByte(Valor);

Serial.println("*************************************");

Serial.print("Vin (Dec): ");

Serial.println(Volt);

Serial.print("A0 (Dec): ");

Serial.println(Valor, DEC);

Serial.print("A0 (Bin): ");

Serial.println(Valor, BIN);

Serial.print("A0 (BIN - HIGH) => Valor * 256: ");

Serial.println(Var_high, DEC);

Serial.print("A0 (BIN - LOW): ");

Serial.println(Var_low, DEC);

delay(1000);

void requestEvent() // Función para enviar datos

Wire.write(Var_high); // Envía MSB -


Wire.write(Var_low); // Envía LSB -

delay(10);

Código 5. Código para esclavo I2C.

20. Compruebe con los respectivos monitores seriales de Arduino IDE en cada computadora

que se realiza correctamente la transferencia de datos. Adicionalmente puede observar

los led’s y verificar que se escribe por separado la parte alta como la parte baja de la

lectura analógica realizada.

Desafíos cortos:

Transfiera una doble palabra (32 bits) del maestro al esclavo en forma de arreglo (array).

Modifique el código del maestro para visualizar en una lcd la misma información que se

muestra en el monitor serial.

21. Desconecte los Arduinos de las computadoras.

22. Desarme y haga entrega del equipo que se le proporcionó en orden.

23. Apague la computadora, incluyendo el monitor.

24. Deje en orden su puesto de trabajo.

1. Realice los ejercicios y los desafíos cortos.

1. Investigue cómo comunicar dos Arduinos con protocolo SPI.

2. Comunique datos entre dos arduinos con comunicación serial asíncrona.

3. Comunique datos entre tres arduinos con comunicación en bus I2C.

Sitio web de los desarrolladores: www.arduino.cc

Referencia en línea del lenguaje: http://arduino.cc/en/Reference/HomePage

Massimo Banzi, “Getting started with Arduino” O'Reilly Media / Make Publisher,

Marzo 2009, ISBN: 978-0-596-15551-3

Actividad complementaria.

Bibliografía.

Análisis de Resultados.


EVALUACION

% 1-4 5-7 8-10 Nota

CONOCIMIENTO

25%

Conocimiento

deficiente de los

fundamentos

teóricos

Conocimiento y

explicación

incompleta de

los fundamentos

teóricos

Conocimiento

completo y

explicación clara

de los

fundamentos

teóricos

APLICACIÓN

DEL

CONOCIMIENTO

70%

No Terminó

completamente

el programa y

comentó mal el

código (30%)

No realizó el

circuito

correctamente

(40%)

Terminó

completamente

el programa pero

los comentarios

no estaban del

todo correctos

El circuito

funcionó

Terminó

completamente el

programa con sus

comentarios

correctos

El circuito

funcionó

ACTITUD 2.5%

Es un

observador

pasivo.

Participa

ocasionalmente

o lo hace

constantemente

pero sin

coordinarse con

su compañero.

Participa

propositiva e

integralmente en

toda la práctica.

2.5%

Es ordenado;

pero no hace un

uso adecuado de

los recursos

Hace un uso

adecuado de los

recursos, respeta

las pautas de

seguridad; pero

es desordenado.

Hace un manejo

responsable y

adecuado de los

recursos conforme

a pautas de

seguridad e

higiene.

TOTAL 100%

Hoja de cotejo: 1

Guía 5: Comunicaciones digitales con Arduino.

Alumno:

Docente:

Maquina N°:

GL: Fecha:

comunicaciones digitales con arduino. · ejemplos de este tipo de comunicación son: i2c one wire...

Documents