Guía para Manejo de Arduino en Raspberry Por I2C

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 6

Guía para manejo de Arduino por medio de I2C en Raspberry Pi 3

Diana Marcela Bayona Ospina


Karla Juliana Ortega Vargas
Oscar Striker Soledad Uribe
Marcos Yeison Caceres Torres
Daniel Eduardo Sandoval Gutiérrez

ING. Luis Evelio Prado Pérez

Universidad de pamplona
Villa del Rosario
Norte De Santander
2019
Que es un arduino
Arduino es una plataforma de creación de electrónica de código abierto, la cual está basada en
hardware y software libre, flexible y fácil de utilizar para los creadores y desarrolladores. Esta
plataforma permite crear diferentes tipos de microordenadores de una sola placa a los que la
comunidad de creadores puede darles diferentes tipos de uso.
El software libre son los programas informáticos cuyo código es accesible por cualquiera para que
quien quiera pueda utilizarlo y modificarlo. Arduino ofrece la plataforma Arduino IDE (Entorno de
Desarrollo Integrado), que es un entorno de programación con el que cualquiera puede crear
aplicaciones para las placas Arduino, de manera que se les puede dar todo tipo de utilidades.
El proyecto nació en 2003, cuando varios estudiantes del Instituto de Diseño Interactivo de Ivrea,
Italia, con el fin de facilitar el acceso y uso de la electrónico y programación. Lo hicieron para que
los estudiantes de electrónica tuviesen una alternativa más económica a las populares BASIC
Stamp, unas placas que por aquel entonces valían más de cien dólares, y que no todos se podían
permitir.
El resultado fue Arduino, una placa con todos los elementos necesarios para conectar periféricos a
las entradas y salidas de un microcontrolador, y que puede ser programada tanto en Windows como
macOS y GNU/Linux. Un proyecto que promueve la filosofía 'learning by doing', que viene a
querer decir que la mejor manera de aprender es cacharreando.

Ventajas y desventajas

 Simplifica: Arduino simplifica el proceso de trabajar con microcontroladores.


 Bajos costos: Las placas Arduino son más accesibles comparadas con otras plataformas
de microcontroladores. Los módulos más caros de Arduino pueden ser montadas a
mano bajando sus costos.
 Multi-Plataforma: El software de Arduino funciona en los sistemas operativos Windows,
Macintosh OSX y Linux; mientras que la mayoría de otros entornos para
microcontroladores están únicamente limitados a Windows.
 Entorno de programación simple y directo: El entorno de programación de Arduino es
fácil de usar para principiantes y flexible para los usuarios avanzados. Además, Arduino
está basado en el entorno de programación de Procesing, con lo que los estudiantes
que aprendan a programar en este entorno se sentirán familiarizados con el entorno de
desarrollo Arduino.
 Software ampliable y de código abierto: El software Arduino es de distribución de licencia
libre y preparado para ser adaptado por programadores experimentados. El lenguaje
puede ampliarse a través de librerías de C++, y en caso de querer profundizar en los
detalles técnicos, se puede dar el salto a la programación en el lenguaje AVR C en el
que está basado.
 Hardware ampliable y de Código abierto. Arduino está basado en los microcontroladores
ATMEGA168, ATMEGA328 y ATMEGA1280. Los planos de los módulos están
publicados bajo licencia Creative Commons, por lo que diseñadores de circuitos con
experiencia pueden hacer su propia versión del módulo, ampliándolo u optimizándolo.
Incluso usuarios relativamente inexpertos pueden construir la versión para placa de
desarrollo para entender cómo funciona y ahorrar algo de dinero.
 Dado que la programación no se realiza en ensambler, el precio a pagar por el uso de
las librerías es un retraso en la ejecución de las instrucciones, algunos microsegundos que en el
caso de dispositivos de uso cotidiano son irrelevantes, pero significativos a la hora de
hacer adquisición de datos.
 El hecho de que la plataforma venga ya ensamblada les quita flexibilidad a los proyectos, asi por
ejemplo estaríamos obligados a usar un espacio y forma acorde con el PCB del arduino, para
superar esto, se debe trabajar con un microcontrolador diferente al de la plataforma y diseñar las
PCB desde cero como con los PICs.

Implementación del arduino en raspberry por comunicación I2C


Se ha estudiado el protocolo I2C de conexión debido a la facilidad que otorga a la hora de escalar el
proyecto, ya que admite hasta 127 periféricos conectados entre sí. Las Raspberry Pi funciona a 3.3V y el
Arduino Mega a 5V, lo cual no es un problema si usamos la Raspberry de maestro, ya que sus 3.3V de
salida alta entran dentro del umbral de entradas altas del Arduino.

Conexión

Los puertos I2C de la Raspberry Pi ya incluyen resistencias Pull-Up de 1.8K. En el Arduino Mega son los
puertos 20 (SDA) y 21 (SCL). Además, las placas deben compartir alimentación y tierra. Al tener
alimentaciones distintas se mantienen separadas. Las conexiones quedan de esta forma:

A continuación, vamos a configurar la placa Raspberry Pi para usar sus dos puertos I2C. En primer lugar,
instalamos el paquete con el siguiente comando i2c-tools:
Después añadimos el módulo para que se cargue con el kernel, añadiendo “i2c-dev” al
fichero /etc/modules-load.d/raspberrypi.conf

Se reinicia y se comprueba si esta funcionando.

Leemos el puerto I2C:

Si todo funciona correctamente. Proseguimos a probar enviando una señal de la Raspberry al Arduino y
que este la devuelva.

Programa para el Arduino

Se crea un programa que reciba un número por el puerto I2C y lo reenvié. Además, si el número es el 1
encenderá o apagará el LED que tiene integrado en la placa.

Hacemos uso de la libería Wire.h y de las llamadas Wire.begin(puerto), Wire.onReceive(función),


Wire.onRequest(función), Wire.available(), Wire.read(), y Wire.write().

El programa nos quedaría así:

#include <Wire.h>

#define SLAVE_ADDRESS 0x04

int number = 0;
int state = 0;

// configuración inicial
void setup () {
pinMode (13, OUTPUT);
// inicializamos i2c como esclavo
Wire.begin(SLAVE_ADDRESS);
// llamadas para la comunicación
Wire.onReceive(receiveData);
Wire.onRequest(sendData);
}

// bucle principal (vacío)


void loop () {}

// llamada para recibir datos


void receiveData (int byteCount) {
while (Wire.available()) {
number = Wire.read();
if (number == 1) {
if (state == 0) {
digitalWrite (13, HIGH); // set the LED on
state = 1;
}
else {
digitalWrite (13, LOW); // set the LED off
state = 0;
}
}
}
}

// llamada para enviar datos


void sendData () {
Wire.write(number);
}

Programa para la Raspberry pi

Este programa escrito en C se conectará con la placa Arduino Mega mediante el protocolo I2C, enviará
un 1 e imprimirá por pantalla la respuesta que reciba del Arduino.

#include <stdio.h>
#include <stdlib.h> // exit
#include <fcntl.h> // open modo O_RDWR
#include <linux/i2c-dev.h>

#define ADDRESS 0x04

int main () {
int file;
unsigned char cmd [16];
int enviado = 1;
char buff [1];
int recibido;

printf ("I2C: Conectando...\n");


if ((file = open ("/dev/i2c-0", O_RDWR)) < 0) {
printf ("I2C: error de acceso");
exit (1);
}

printf ("I2C: Accediendo al dispositivo \n");


if (ioctl (file, I2C_SLAVE, ADDRESS) < 0) {
printf ("I2C: error al acceder al esclavo en 0x%x", ADDRESS);
exit (1);
}

Printf ("Enviado %d\n", enviado);


Cmd [0] = enviado;
if (write (file, cmd, 1) == 1) {
usleep (10000);
if (read (file, buff, 1) == 1) {
recibido = (int) buff [0];
printf ("Recibido %d\n", recibido);
}
}

printf ("I2C: Terminando...\n");


close (file);
return (EXIT_SUCCESS);
}

Compilamos el programa y lo ejecutamos.

1 > ./i2c
2 I2C: Conectando...
3 I2C: Accediendo al dispositivo
4 Enviado 1
5 Recibido 1
6 I2C: Terminando..

Cada vez que ejecutamos el programa desde la Raspberry Pi, el LED integrado en el Arduino Mega
se enciende o apaga correctamente.

Detectando de nuevo las conexiones I2C vemos que el Arduino está correctamente conectado en el
puerto 4.

> i2cdetect -y 0
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- 04 -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

También podría gustarte