LABORATORIO SPI/I2C

REDES DE COMUNICACION INDUSTRIAL

SPI I2C

DOCENTE:

MSc. VICTOR ARDILA ACUÑA

ESTUDIANTE:

JUAN SEBASTIAN TRASLAVIÑA DAVILA

ALVARO JULIAN GONZALEZ CARDENAS

UNIVERSIDAD AUTONOMA DE BUCARAMANGA

2018
LISTA DE MATERIALES
- 2 ARDUINO MEGA.
- CABLE USB.
- PROTOBOARD.
- CONECTORES ARDUINO.
- LCD 16X2.
- Sensor De Temperatura MAX6675
- Módulo I2C Para Control LCD 2x1.
- Pantalla LCD 2x1

Problema
Se requiere realizar la comunicación serial entre dos arduinos, uno como maestro y otro como
esclavo, donde el maestro se comunicará por I2C a una pantalla LCD de 16*2 y este debe mostrará
en pantalla todos los datos recibidos por el esclavo. El esclavo estará enviado tres datos los cuales
son dos numero para realizar una operación matemática y un dato de un sensor el cual va a estar
comunicado con medio de una comunicación SPI y no se pueden usar la librería del sensor se debe
adecuar la señal por código recibida.

Solución

Comunicación Serial:

La comunicación serie es muy importante porque gran parte de los protocolos utilizados
actualmente son serie y además muchos dispositivos de comunicación inalámbrica usan la
comunicación serie para hablar con Arduino como los módulos bluetooth y los módulos Xbee.
También la comunicación serie es la que se usa generalmente para comunicar el Arduino con el
Ordenador.

Todas las placas Arduino tienen al menos un puerto serie disponible en los pines digitales 0 (RX) y
1 (TX) compartido con el USB. Por lo tanto no es posible usar estos pines como entradas/salidas
digitales.

El Arduino mega dispone de tres puertos adicionales Serial1 on pins 19 (RX) and 18 (TX), Serial2 on
pins 17 (RX) and 16 (TX), Serial3 on pins 15 (RX) and 14 (TX). Estos pines no están conectados al
interfaz USB del Arduino.

Comunicación serie:
Comunicación SPI

El Bus SPI (del inglés Serial Peripheral Interface) es un estándar de comunicaciones, usado
principalmente para la transferencia de información entre circuitos integrados en equipos
electrónicos. El bus de interfaz de periféricos serie o bus SPI es un estándar para controlar casi
cualquier dispositivo electrónico digital que acepte un flujo de bits serie regulado por un reloj
(comunicación sincrónica).

Incluye una línea de reloj, dato entrante, dato saliente y un pin de chip select, que conecta o
desconecta la operación del dispositivo con el que uno desea comunicarse. De esta forma, este
estándar permite multiplexar las líneas de reloj.

Muchos sistemas digitales no necesitan una conexión rápida con sus periféricos. La ventajas de un
bus serie es que minimiza el número de conductores, pines y el tamaño del circuito integrado. Esto
reduce el coste de fabricar, montar y probar la electrónica. Un bus de periféricos serie es la opción
más flexible cuando se tiene tipos diferentes de periféricos serie. El hardware consiste en señales
de reloj, data in, data out y chip select para cada circuito integrado que tiene que ser controlado.
Casi cualquier dispositivo digital puede ser controlado con esta combinación de señales. Los
dispositivos se diferencian en un número predecible de formas. Unos leen el dato cuando el reloj
sube, otros cuando el reloj baja. Algunos lo leen en el flanco de subida del reloj y otros en el flanco
de bajada. Escribir es casi siempre en la dirección opuesta de la dirección de movimiento del reloj.
Algunos dispositivos tienen dos relojes. Uno para capturar o mostrar los datos y el otro para el
dispositivo interno.

Comunicación I2c

I2C PIC es uno de los modos de trabajo del módulo SSP puerto serial síncrono del microcontrolador
PIC, en la comunicación I2C se utilizan 2 hilos a lo que se conoce como bus I2C, a estos hilos se
conectan los dispositivos que se puedan comunicar mediante el protocolo I2C, por uno de los hilos
se enviará una señal de reloj para la sincronización y por el otro hilo se enviarán o recibirán datos,
se pueden conectar varios dispositivos de los que uno de ellos será el maestro, es el que generará
la señal de reloj además de decidir cuándo se inicia o finaliza la comunicación y si la comunicación
será de recepción o transmisión de datos, los demás dispositivos conectados al bus I2C se conocen
como esclavos.
Cada uno de los dispositivos tiene una dirección, cuando el maestro necesita comunicarse con
alguno de los esclavos lo hará enviando la dirección del esclavo a través del bus I2C, cuando el
esclavo reciba su dirección podrá comunicarse con el maestro, el maestro además tiene que enviar
un bit mediante el cual le indica al esclavo si quiere enviarle un dato o quiere recibir un dato del
esclavo.
MONTAJE
Se muestra a continuación el montaje utilizado para la realización de la práctica del laboratorio:

Maestro Esclavo

PROGRAMA (ARDUINO) ESCLAVO

En este segmento se declaran e inicializan las variables, se incluyen las librerías necesarias para el
I2C y para la pantalla LCD.

int Sum=0;
int Res=0;
int Mul=0;
double Div=0;
int N1=0;
int N2=0;
String text;
double temperatura;
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F,16,2);

En este segmento se inicializa las comunicaciones y se inicializa la pantalla LCD.

void setup(){
Serial2.begin(9600);
Serial1.begin(9600);
Serial.begin(9600);
lcd.init();
lcd.backlight();

}
En este segmento se cuadran los ciclos en los cuales se lee la variable que envía el arduino
esclavo, también se realizan las operaciones necesarias entre los números ingresados. Por
otro lado se imprime en la pantalla los resultados entre los números ingresados y en
tiempo real la temperatura.

void loop()
{

if (Serial1.available()>0){
while(!Serial1.available());
N1 = Serial1.read();
delay(2000);

while(!Serial1.available());
N2 = Serial1.read();
delay(2000);
Sum=N1+N2;
Res=N1-N2;
Mul=N1*N2;
Div = N1/N2;

Serial.println(N1);
Serial.println(N2);
Serial.println(Sum);
Serial.println(Res);
Serial.println(Mul);
Serial.println(Div);
lcd.setCursor(0, 0);
lcd.print(Sum);
lcd.print(" ");
lcd.print(Res);
lcd.print(" ");
lcd.print(Mul);
lcd.print(" ");
lcd.print(Div);
}
if (Serial2.available()>0){
while(!Serial2.available());
text = Serial2.read();
temperatura = text.toInt();

Serial.println((float)temperatura/4.0,DEC);
lcd.setCursor(0, 1);
 lcd.print((float)temperatura/4.0,DEC);

}
}

PROGRAMA (ARDUINO) ESCLAVO

En este segmento se declaran las variables y se define el pin del arduino que se le va a conectar la
señal cs, se le define también el tiempo de muestreo, también se incluyen las librerías timerone y
la de la comunicación SPI entre el sensor de temperatura y el arduino esclavo
#define PIN_CS 53 // Pin de Arduino al que se conecta la señal CS
#define ESPERA_ENTRE_LECTURAS 250 // Tiempo de muestre (al menos 250 ms por
seguridad)
#include <TimerOne.h>
#include <SPI.h> // Añadir al código la librería de comunicaciones SPI
int numero1 ;
int numero2;
int numero3 ;
int numero4;
int inicio;
int temperatura; // Entero en el que se almacenan los datos recibidos desde el MAX6675

En este segmento se inician los protocolos para los pines y los temporizadores donde se
lee la temperatura y donde se cuadran todos los ingresos por el monitor serial de los
números sobre los cuales se va a realizar las operaciones.

void setup(){

Serial.begin(9600);
Serial1.begin(9600);
Serial2.begin(9600);
SPI.begin(); // Inicializar las comunicaciones SPI
pinMode(PIN_CS,OUTPUT); // Declarar como salida el pin CS
digitalWrite(PIN_CS,HIGH); // Establecer CS a nivel alto (inhabilitar las comunicaciones
SPI)
Timer1.initialize(1000000); // Dispara cada 500 ms
Timer1.attachInterrupt(Sensor_Temperatura ); // Activa la interrupcion y la asocia a
ISR_Blink

}
void loop()
{

Serial.println("Desea realizar las operaciones? marque 1 para si 0 para no");

delay(2000);
inicio=Serial.parseInt();
if(inicio==1){
Serial.println("escriba el primer numero");
//while(!Serial.available())
delay(2000);
numero1=Serial.parseInt();
Serial.println(numero1);
Serial1.write(numero1);

Serial.println("escriba el segundo numero");

//while(!Serial.available());
delay(2000);
numero2 = Serial.parseInt();
Serial.println(numero2);
Serial1.write(numero2);
}

}
void Sensor_Temperatura ()
{
digitalWrite(PIN_CS,LOW); // Habilitar las comunicaciones SPI
temperatura=SPI.transfer(0); // Recibir el byte más significativo
temperatura<<=8; // Colocar los 8 bits más significativos en su posición
temperatura|=SPI.transfer(0); // Añadir los 8 bits del siguiente byte
digitalWrite(PIN_CS,HIGH); // Desactivar las comunicaciones SPI
temperatura>>=3; // Reubicar en la variable los datos de la temperatura (para que el LSB
del valor quede en su posición)
Serial.print("Temperatura: "); // Mostrar un mensaje para identificar qué temperatura se
está monitorizando (un horno de cerámica, por ejemplo)
Serial.print((float)temperatura/4.0,DEC); // Dividir el valor entre 4 (el valor representa
cuartos de grado)
Serial.println(" °C"); // Indicar las unidades en las que se muestra la temperatura
Serial2.write(temperatura);
}
COMPROBACIÓN DE FUNCIONAMIENTO
Se comprobó la comunicación entre los dispositivos en tiempo real enviando diferentes datos desde
el monitor serie del esclavo y observado el cambio de temperatura que se tenía dado por el sensor
de temperatura.

Se adjunta link para descarga del video.

CONCLUSIONES
 Se observó que los protocolos de comunicación facilitan el envío y recepción de datos entre
dispositivos que tienen una función diferente.
 Se concluyó que la comunicación serial es un poco complicada debido a que un dispositivo
recibe una trama de información y el programador tiene que encontrar la forma de saber cuál
es la información de ese tramo de datos que se requiere para su uso.
 Se observó que para leer datos de un sensor que funcione con comunicación SPI es
necesario que el programador revise el datasheet del sensor debido a que necesita saber
cuáles son los bits que el dispositivo designa para enviar la información.
 Se observó que al utilizar el monitor serie, se necesitó estar poniéndole diferentes delays
para darle tiempo al usuario de responder a lo que se está necesitando.