Raspberry Pi – Asignando un dominio .local

Es muy probable que ha estas altura estemos bien familiarizados con el comando ifconfig, un comando que nos permite conocer la dirección IP que se le ha asignado a nuestra Raspberry Pi y que sirve de referencia para muchas de las actividades que podemos hacer con ella, acceso SSH, VNC, Web, etc.

¿Pero que sucede cuando por alguna razon olvidamos la IP, o reiniciamos el Router y le asigna una dirección diferente a la Raspi?, en el mejor de los casos tenemos el teclado y monitor conectados para ver en pantalla la nueva IP, pero, ¿y si no es así? estoy seguro que para muchos esto ha sido un gran dolor de cabeza.

Una de las maneras mas fáciles y rápidas de darle solución a este problema, es aplicando una técnica conocida como mDNS o Multicasting Domain Name Servicing, que básicamente consiste en tener un pequeño servicio (demonios en linux) en nuestra Raspi que le permita ser descubierta por cualquier equipo en la red a través de un nombre de dominio.

Antes de empezar con la instalación es importante tener las referencias y el software de nuestra Raspi actualizado, esto básicamente es una costumbre a considerar para mantener al día nuestro software y reducir al máximo los posibles bugs entre versiones. Para hacerlo solo ejecutamos:

sudo apt-get update

sudo apt-get upgrade

En caso de que aparezca algún tipo de mensaje solo tecleamos “Y” para que continue con la instalación. Posteriormente instalaremos “Avahi”, el servicio que mantendrá nuestra tarjeta visible en la red:

sudo apt-get install avahi-daemon

Prácticamente con esto seria suficiente, pero podemos mejorarlo aun mas definiendo algún nombre de dominio único que podamos recordar con facilidad y que suele ser de gran ayuda para cuando tenemos mas de una Raspberry Pi conectada a la misma red.

Para lograr este ultimo paso editamos los archivos:

sudo nano /etc/hosts

Y cambiamos la palabra “raspberrypi” de la ultima linea por el nombre que queramos asignarle, “robotcos” en mi caso. Y del mismo modo el archivo:

sudo nano /etc/hostname

reiniciamos para terminar y deberíamos poder acceder de la manera que queramos (SSH, VNC, Web) con el nombre que asignamos de la siguiente manera:

ssh pi@robotcos.local

.local es una extension reservada para LANs, por lo que al ser interpretada por un router automáticamente hace una búsqueda en la red local.

Simple no!? y mucho mas fácil de recordar que una dirección IP.

 

Raspberry Pi – Drivers TL-WN725N

Como ya hemos hablado en este blog, una de las maneras mas practicas de conectar nuestra Raspberry a la red y a internet es mediante WiFi, ya que así tenemos esa libertad de movernos sin problemas de cables. Existe muy poca variedad de adaptadores USB compatibles con el sistema de nuestra tarjeta y es probable que algunos de estos no los encontremos ni en la tienda mas popular de nuestra ciudad, por lo que recurrimos a comprar cualquier modelo que al llegar a casa no nos servirá.

En esta entrega veremos como agregar algunos drivers, para lograr expandir la compatibilidad de nuestra Raspi, específicamente para TL-WN725N de TP-LINK, que suele ser uno de los mas fáciles de encontrar.

El primer paso es revisar la version de Linux que tenemos instalada, el comando uname -a devuelve una descripción similar a:

Linux raspberrypi 3.12.28+ #709 PREEMPT Mon Sep 8 15:28:00 BST 2014 armv6l GNU/Linux

De esta información lo que tomaremos para mas adelante es la parte 3.12.28+ #709, tengamos en cuenta que este dato puede variar para cualquiera.

En el siguiente paso debemos conectar el adaptador y mostrar el listado de los dispositivos conectados con el comando lsusb, encontraremos la descripción similar a:

Bus 001 Device 005: ID 0bda:8179 Realtek Semiconductor Corp.

Que corresponde al index y ID del adaptador USB que conectamos, el driver que instalaremos esta limitado a dispositivos con los siguientes IDs:

ID 2001:3310
ID 2001:330F
ID 07B8:8179
ID 0BDA:0179
ID 0BDA:8179

y para versiones de linux superiores a  3.12.28:

ID 056E:4008
ID 2001:3311
ID 0DF6:0076

Una vez que se tenga esta información tendremos que encontrar la relación con el archivo que tenemos que instalar en el siguiente listado:

	########################################################################
	3.6.11+ #371 up to #520 inclusive – 8188eu-20130209.tar.gz
	3.6.11+ #524, #528, #532 – 8188eu-20130815.tar.gz
	3.6.11+ #538, #541, #545, #551, #557 – 8188eu-20130830.tar.gz
	########################################################################
	3.10.18+ #577 – 8188eu-20131105.tar.gz
	3.10.18+ #579, #585 – 8188eu-20131106.tar.gz
	3.10.18+ #587 – 8188eu-20131110.tar.gz
	3.10.18+ #590, #592 – 8188eu-20131111.tar.gz
	3.10.18+ #594, #596 – 8188eu-20131113.tar.gz
	3.10.19+ #600 – 8188eu-20131113.tar.gz
	3.10.21+ #602, #604 – 8188eu-20131113.tar.gz
	3.10.22+ #606 – 8188eu-20131206.tar.gz
	3.10.23+ #608 – 8188eu-20131209.tar.gz
	########################################################################
	3.10.24+ #610 – 8188eu-20131209.tar.gz
	3.10.24+ #614 – 8188eu-20131219.tar.gz
	3.10.25+ #616, #618 – 8188eu-20131219.tar.gz
	3.10.25+ #622, #624 – 8188eu-20131219.tar.gz
	3.10.26+ #628 – 8188eu-20140110.tar.gz
	3.10.27+ #630 – 8188eu-20140117.tar.gz
	3.10.28+ #632, #634 – 8188eu-20140117.tar.gz
	3.10.29+ #636, #638 – 8188eu-20140117.tar.gz
	########################################################################
	3.10.30+ #640, #642 – 8188eu-20140117.tar.gz
	3.10.32+ #646, #648 – 8188eu-20140117.tar.gz
	3.10.33+ #654, #656 – 8188eu-20140117.tar.gz
	3.10.33+ #658 – 8188eu-20140117.tar.gz
	3.10.34+ #660, #661 – 8188eu-20140117.tar.gz
	3.10.36+ #662, #664 – 8188eu-20140117.tar.gz
	3.10.36+ #665, #666 – 8188eu-20140117.tar.gz
	3.10.37+ #667, #669 – 8188eu-20140117.tar.gz
	########################################################################
	3.10.38+ #675 – 8188eu-20140117.tar.gz
	########################################################################
	3.12.18+ #673, #677 – 8188eu-20140425.tar.gz
	3.12.18+ #679, #680 – 8188eu-20140501.tar.gz
	3.12.19+ #681, #682 – 8188eu-20140509.tar.gz
	3.12.19+ #684 – 8188eu-20140509.tar.gz
	3.12.20+ #685, #686 – 8188eu-20140509.tar.gz
	3.12.20+ #687 – 8188eu-20140509.tar.gz
	3.12.21+ #688, #689 – 8188eu-20140509.tar.gz
	3.12.22+ #690, #691 – 8188eu-20140616.tar.gz
	########################################################################
	3.12.23+ #692 – 8188eu-20140626.tar.gz
	3.12.24+ #693, #694 – 8188eu-20140705.tar.gz
	3.12.25+ #698, #700 – 8188eu-20140705.tar.gz
	3.12.25+ #701 – 8188eu-20140705.tar.gz
	3.12.26+ #702, #703 – 8188eu-20140705.tar.gz
	3.12.26+ #704, #707 – 8188eu-20140705.tar.gz
	3.12.26+ #708 – 8188eu-20140705.tar.gz
	3.12.28+ #709, #710 – 8188eu-20140908.tar.gz
	3.12.28+ #712, #713 – 8188eu-20140908.tar.gz
	########################################################################
	3.12.29+ #714, #715 – 8188eu-20140908.tar.gz
	3.12.30+ #717 – 8188eu-20141017.tar.gz
	3.12.31+ #718, #720 – 8188eu-20141026.tar.gz
	3.12.32+ #721 – 8188eu-20141107.tar.gz
	3.12.33+ #722, #724 – 8188eu-20141107.tar.gz
	3.12.34+ #725, #727 – 8188eu-20141107.tar.gz

view raw

rtl8188eu drivers

hosted with ❤ by GitHub

Para mi caso  3.12.28+ #709, #710 – 8188eu-20140908.tar.gz hace match con la version de linux que tengo instalada por lo que 8188eu-20140908.tar.gz es el archivo que tendré que instalar.

	wget https://dl.dropboxusercontent.com/u/80256631/8188eu-201xyyzz.tar.gz
	tar -zxvf 8188eu-201xyyzz.tar.gz
	sudo install -p -m 644 8188eu.ko /lib/modules/$(uname -r)/kernel/drivers/net/wireless
	sudo insmod /lib/modules/$(uname -r)/kernel/drivers/net/wireless/8188eu.ko
	sudo depmod -a

view raw

rtl8188eu install

hosted with ❤ by GitHub

La serie de comandos anteriores indica la forma de descargar e instalar, recuerden cambiar 8188eu-201xyyzz.tar.gz por el del archivo correcto para su version, 8188eu-20140908.tar.gz en mi caso.

Si llegamos hasta aquí sin ningún problema, solo restaría configurar las credenciales de nuestra red como hemos visto anteriormente (WiFi Setup) y reiniciar la Raspberry Pi, espero les sirva :).

Referencia: Raspberrypi.org (ingles)

Raspberry Pi – Multiples redes WiFi

En uno de nuestros post anteriores hablamos de como configurar nuestra Raspi para conectarse de manera automática a la red utilizando un adaptador USB-WiFi (ver aqui), así como hablamos de acceder de manera remota desde otro equipo utilizando herramientas como VNC o SSH (ver aqui), lo cual nos facilita la vida al no tener que comprar un monitor y accesorios solo para usarlos con nuestra tarjeta.

Hasta aquí todo es felicidad, la Raspi se conecta al iniciar, entramos a ella por SSH o al modo gráfico por VNC y trabajamos en casa u oficina sin ningún problema, pero ¿que pasa cuando me tengo que mover? si necesito conexión tengo que volver a configurar la raspberry para la nueva red ¿cierto? y ocupare monitor y accesorios nuevamente, ¿tendré que llevarlo conmigo a todo lados?.

Bueno pues una de las soluciones mas simples y rápidas es configurar nuestra tarjeta para que recuerde el mayor numero de redes o puntos de acceso a los que posiblemente se podría conectar, la casa, la oficina, la escuela, la casa de un amig@, etc.

Para que esto funcione el primer archivo a editar es:

sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

y tendríamos que dejarlo similar a:

	ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
	update_config=1
	network={
	ssid="Red1"
	psk="passwordRed1"
	id_str="AliasRed1"
	}
	network={
	ssid="Red2"
	psk="passwordRed2"
	id_str="AliasRed2"
	}

view raw

wpa_supplicant

hosted with ❤ by GitHub

como vemos tenemos que crear un objeto “network” por cada red que nuestra Raspi recordara, así como un alias para cada una dentro del parametro id_str.

Y el segundo archivo es:

sudo nano /etc/network/interfaces

y tendría que quedar como sigue:

	auto lo
	iface lo inet loopback
	iface eth0 inet dhcp
	allow-hotplug wlan0
	auto wlan0
	iface wlan0 inet manual
	wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
	iface AliasRed1 inet dhcp
	iface AliasRed2 inet dhcp

view raw

wpa_interfaces

hosted with ❤ by GitHub

es muy similar al que teníamos anteriormente la única diferencia es que se agrega la referencia al archivo donde configuramos los datos de acceso y como manejara cada una de las redes. Y eso es todo! en teoría cada que nuestra Raspi encienda tratara de conectarse a cada una de las redes que hayamos listado en el archivo en el mismo orden en el que se pusieron, Red1, Red2, etc. hasta que logre una conexión. Sin duda para nosotros ha sido de gran ayuda puesto que ya no necesitamos de monitor y accesorios cada que hay que moverse, procuramos llevar listadas todas las posibles redes para conectarnos sin problema, incluso la de nuestro telefono para cuando las redes fallan y tenemos que compartir el internet, ojala les sirva tambien 🙂

 

Lección 27 – Arduino – Sensor de Movimiento PIR

Los sensores PIR son dispositivos electrónicos que nos permiten detectar el movimiento dentro rango determinado, según las característica de cada uno, los podemos encontrar en diferentes presentaciones y modos de operar, en la imagen vemos algunos de los mas comunes.

Los sensores PIR (Passive Infrared) se caracterizan principalmente por su reducido tamaño, bajo costo, indiferencia a la luz natural, bajo consumo de energia y fácil manejo, razon por la que hoy dia se emplean en infinidad de proyectos e incluso en productos de consumo (como las lamparas comerciales que encienden al detectar movimiento).

¿Como usarlos?

Otra de las grandes ventajas de estos componentes, es que ya cuentan con gran parte de la electronica necesaria para operar y solo tenemos que agregar un par de conexiones para empezar a usarlos, veamos como empleando un Arduino.

Como vemos en el esquema, el sensor que estamos utilizando se alimenta directamente de los 5v que nos proporciona Arduino por lo que no sera problema conectar su linea de señal directamente a un pin digital. Según las especificaciones del modelo la linea de señal en el sensor es 0 en estado de reposo y pasa a 1 cuando detecta movimiento así que podemos leer la señal como cualquier señal digital.

	/*
	Implementación básica de un sensor de movimiento (PIR)
	*/
	const int buttonPin = 2;
	const int ledPin = 13;
	int buttonState = 0;
	void setup() {
	pinMode(ledPin, OUTPUT);
	pinMode(buttonPin, INPUT);
	Serial.begin(9600);
	}
	void loop(){
	buttonState = digitalRead(buttonPin);
	if (buttonState == HIGH) {
	digitalWrite(ledPin, HIGH);
	}
	else {
	digitalWrite(ledPin, LOW);
	}
	Serial.println(buttonState);
	delay(500);
	}

view raw

PIRsensor.ino

hosted with ❤ by GitHub

Realmente sencillo verdad?, lo mejor de todo es la cantidad de proyectos que podemos realizar, podríamos incluso conectar varios sensores en red al mismo pin para ampliar el umbral que queramos monitorear, imaginen un cuarto donde solo se encienda la luz en presencia de alguien o una alarma para que no se acerquen a nuestras cosas, en fin, estoy seguro que se les ocurre algo 🙂

A considerar

Como lo comentamos en un inicio, existen diferentes modelos de este tipo de sensores, algunos como el que hemos utilizado, viene con un par de potenciómetros para ajustar la sensibilidad de detección y el tiempo para regresar a “reposo” ademas de un conector “jumper” para inhabilitarlo. Por otro lado también podemos encontrar algunos que funcionan como Colector Abierto, que quiere decir esto, que al momento de detectar el movimiento su linea de señal pasa a tierra (GND), por lo que tendríamos que agregar una resistencia Pull-Up para leer correctamente los cambios de estado.

Lección 24 – Arduino – Optoacopladores

Los optoacopladores son componentes electrónicos que funcionan a manera de conmutador, interruptor o switch, básicamente se componen de un diodo LED que satura a  un elemento optoelectronico (de ahi su nombre), normalmente en forma de fototransistor o fototriac. Los podemos encontramos en empaquetados que combinan a estos elementos o a un arreglo de ellos.

 

Una de sus principales funciones es aislar circuitos electrónicos sensibles o de caracteristicas diferentes, como sucede cuando el voltaje de operación varia, un caso practico puede ser el control de relevadores o solenoides de gran voltaje de operación (de 12v a 36v) a través de un Arduino (5v).

Para este post hemos probado dos modelos, el 4N26 y el PC817 ambos muy similares aunque en diferente presentación.

la gran diferencia entre estos dos modelos, como se ve en la imagen, es que el 4N26 tiene un pin adicional desde donde podemos activar el fototransistor si así se desea e independientemente al estado del Led.

Existe gran variedad de este tipo de componentes, aunque el modo de implementarlos sigue siendo el mismo pueden diferir en el voltaje o amperaje que llegan a controlar o incluso en el tipo de corriente que pueden manejar, tal es el caso de los que incluyen un fototriac, que son capaces de trabajar con corrientes alternas.

Es importante que revisemos las hojas de datos ya que ahi encontraremos la información necesaria sobre cada uno de los modelos que existen en el mercado, ademas que es de gran ayuda a la hora de estar diseñando nuestros proyectos.

Bien! para verlos en acción tomaremos como base la siguiente imagen, y para un ejemplo simple usaremos el sketch del Blink que viene en el IDE del Arduino, haciendo una modificación en los delay a 10000 para notar aun mejor el funcionamiento.

Si no cuentan con un solenoide pueden usar cualquier elemento que requiera de un voltaje mayor a los 5V o igual pero alimentado con una fuente externa a la del Arduino, incluso puede ser un multimetro 🙂

 

Lección 23 – Arduino – Nokia 5110 LCD

El LCD es uno de los componentes que no pueden faltar a la hora de crear proyectos “interactivos”, sin duda ya conocido por todos, aun y cuando no se tiene conocimiento de sistemas embebidos o electronica, los podemos encontrar en la gran variedad de dispositivos que operamos del día a día, teléfonos, microondas, estufas, refrigeradores, maquinas expendedoras, etc., monocromáticos o de color, siempre los vemos por ahí, ya que en gran medida, es gracias a estos componentes que podemos “comunicarnos” con los aparatos.

En esta ocasión usaremos el modelo de Nokia 5110, un modulo integrado monocromático de 84 pixeles de ancho y 48 de alto, veamos algunas de las cosas que necesitamos:

• Arduino, por supuesto.
• LCD Nokia modelo 5110 (Adafruit, Sparkfun)
• 4 resistencias de 10kOhms
• 1 resistencia de 1kOhms
• 1 resistencia de 220Ohms
• Cables (jumpers)
• Protoboard

Una ves tengamos los componentes a la mano, podemos basarnos en el siguiente esquema para armar el circuito.

La mayoría de los LCD de este modelo vienen con la misma configuración de pines, así que no deberíamos tener problemas al conectar, si algo resulta mal es probable que el fabricante de tu modulo haya cambiando algunos pines, podemos basarnos en la siguiente tabla para conectar correctamente.

 

Pin	Label	Función	Descripción
1	VCC	3v3	El rango de voltaje aplicado puede variar entre 2v7 y 3v3
2	GND	Ground
3	SCE	Chip select	Resistencia de 1k
4	RST	Reset	Resistencia de 10k
5	D/C	Mode select	Resistencia de 10k
6	DN(MOSI)	Serial data in	Resistencia de 10k
7	SCLK	Serial clock	Resistencia de 10k
8	LED	LED backlight	Voltaje máximo de 3v3 + resistencia de 220

Es importante que el pin de VCC este conectado al pin 3v3 de Arduino y las resistencias entre los pines, puesto que el voltaje de operación es menor al del Arduino.

Suponiendo que todo va bien hasta aquí, continuemos con el programa. Dentro de este modulo encontramos un controlador de Phillips modelos PCD8544, el cual maneja los datos de una manera similar a la comunicación SPI pero gracias a la gran comunidad que existe, podemos encontrar algunas librerías que nos facilitan el trabajo pesado de interpretar protocolos de comunicación, listamos algunas:

1. PCD8544 Arduino library
2. Adafruit LCD library (se requiere la libreria grafica GFX)
3. h3r0 ejemplo (foro de Arduino)

Hemos probado las tres opciones y nos han funcionado a la perfección, ya depende de que tan complejo sean los gráficos que queramos mostrar, para nuestro caso tomamos la ultima y le agregamos nuestro plus, es mas sencilla de entender y no requiere ninguna otra librerías adicional.

	/*
	September 5th, 2011
	Wade Smith
	Based on code by Nathan Seidle
	This code is free and open, like NyanCat
	Written for the Nokia 5110 84×48 graphic LCD:
	http://www.sparkfun.com/products/10168
	http://www.adafruit.com/products/338
	*/
	#define PIN_SCE 7
	#define PIN_RESET 6
	#define PIN_DC 5
	#define PIN_SDIN 4
	#define PIN_SCLK 3
	//The DC pin tells the LCD if we are sending a command or data
	#define LCD_COMMAND 0
	#define LCD_DATA 1
	//You may find a different size screen, but this one is 84 by 48 pixels
	#define LCD_X 84
	#define LCD_Y 48
	char hhmx[] = {
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
	0x80, 0x80, 0x80, 0x80, 0xFC, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0xC6, 0xF0, 0x38, 0x1C,
	0x0E, 0xC7, 0xE3, 0x63, 0xE1, 0xC1, 0xE1, 0x78, 0x18, 0x18, 0x78, 0xE1, 0xC1, 0xE1, 0x63, 0xE3,
	0xC7, 0x0E, 0x1C, 0x38, 0xF6, 0xC7, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30, 0xFF,
	0xFF, 0x00, 0x00, 0x78, 0x78, 0xD9, 0xDF, 0x8F, 0x00, 0x00, 0xF8, 0xDC, 0x8C, 0x8C, 0xDC, 0xFC,
	0x20, 0x00, 0x87, 0xCF, 0xD9, 0x78, 0x78, 0x00, 0x00, 0xFF, 0xFF, 0x30, 0x30, 0x30, 0x30, 0x30,
	0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x07, 0x0F, 0x3C, 0x70, 0xE0, 0x8C, 0x1F, 0x3B, 0x18, 0x1C, 0x1E, 0x0F,
	0x01, 0x01, 0x07, 0x1E, 0x0C, 0x18, 0x3B, 0x1F, 0x8E, 0xE0, 0xF0, 0x3C, 0x0F, 0x07, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x8F, 0xFE, 0xF0,
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFE, 0x9F, 0x03, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x01, 0x03, 0x3B, 0x3B, 0x3B, 0xFB, 0xFB, 0xFB, 0xFB, 0xFB, 0xFB, 0xFB, 0xFB, 0x3B, 0x3B, 0x3B,
	0x0B, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	};
	void setup(void) {
	LCDInit(); //Init the LCD
	}
	void loop(void) {
	LCDBitmap(hhmx);
	}
	void gotoXY(int x, int y) {
	LCDWrite(0, 0x80 | x); // Column.
	LCDWrite(0, 0x40 | y); // Row. ?
	}
	void LCDBitmap(char my_array[]){
	for (int index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++)
	LCDWrite(LCD_DATA, my_array[index]);
	}
	void LCDClear(void) {
	for (int index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++)
	LCDWrite(LCD_DATA, 0x00);
	gotoXY(0, 0);
	}
	//This sends the magical commands to the PCD8544
	void LCDInit(void) {
	//Configure control pins
	pinMode(PIN_SCE, OUTPUT);
	pinMode(PIN_RESET, OUTPUT);
	pinMode(PIN_DC, OUTPUT);
	pinMode(PIN_SDIN, OUTPUT);
	pinMode(PIN_SCLK, OUTPUT);
	//Reset the LCD to a known state
	digitalWrite(PIN_RESET, LOW);
	digitalWrite(PIN_RESET, HIGH);
	LCDWrite(LCD_COMMAND, 0x21); //Tell LCD that extended commands follow
	LCDWrite(LCD_COMMAND, 0xB0); //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
	LCDWrite(LCD_COMMAND, 0x04); //Set Temp coefficent
	LCDWrite(LCD_COMMAND, 0x14); //LCD bias mode 1:48: Try 0x13 or 0x14
	LCDWrite(LCD_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode
	LCDWrite(LCD_COMMAND, 0x0C); //Set display control, normal mode. 0x0D for inverse
	}
	//There are two memory banks in the LCD, data/RAM and commands. This
	//function sets the DC pin high or low depending, and then sends
	//the data byte
	void LCDWrite(byte data_or_command, byte data) {
	digitalWrite(PIN_DC, data_or_command); //Tell the LCD that we are writing either to data or a command
	//Send the data
	digitalWrite(PIN_SCE, LOW);
	shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
	digitalWrite(PIN_SCE, HIGH);
	}

view raw

Nokia5110.ino

hosted with ❤ by GitHub

cargamos el sketch a nuestro Arduino y en un momento estaríamos viendo el logo en pantalla.

 

Pasando imágenes personalizadas:

Para poder agregar nuestras propias imágenes a partir de Mapa de Bits (.bmp) hemos probado la aplicación de LCD Assistant, la cual nos crea un arreglo de bytes que corresponden los pixeles en pantalla, solo tenemos que configurar las magnitudes, 84×48 en nuestro caso.

 

La opción File -> Save output nos da el resultado en texto, y podemos copiar el arreglo y pegarlo en nuestro ejemplo para ver los cambios (linea 26 – char hhmx[]={ } ).

Y eso es todo, espero les sea de utilidad y podamos ver algunos proyectos a la luz muy pronto 🙂

 

 

 

Fabricación casera de PCBs

A medida que avanzamos como #Maker, descubrimos lo sencillo que pueden llegar a ser construir nuestras propias cosas, empezamos a construir y ensamblar como locos por todos lados, echamos a volar la imaginación y en ocasiones la idea tan descabellada en la que pensamos un día no parece estar tan lejos de la realidad. Es un momento cercano a este cuando nuestras necesidades empiezan a crecer y la Proto Board parece ser insuficiente para implementar nuestros tan amados proyectos. Es por esta razón que en #HHMX hemos preparamos esta pequeña guía sobre fabricación casera de PCBs que espero sea de utilidad para dar el siguiente paso como Makers. Materiales:

• PCB virgen (Placa de baquelita o fibra de vidrio con cara de cobre).
• Papel transfer, Papel cebolla o Papel arroz (Cualquier tipo de papel encerado puede servir).
• Plancha para ropa.
• x-acto.
• Pinzas tweezers.
• Pinzas de plastico.
• Marcador de punto fina.
• Cloruro Férrico.
• Taladro (herramienta rotativa con punta de 1/32”).
• Recipiente amplio.
• Sierra (manual o eléctrica).

El proceso 1. Antes que todo pues obviamente necesitamos el diseño de nuestro proyecto, supongo que cada quien se inclina por algún favorito, Eagle, KiCad o incluso Fritzing. Bueno pues sea cual sea tenemos que imprimir las pistas o rutas de nuestro proyecto diseñado, solo asegúrense de imprimir únicamente las pistas y no la parte que va en serigrafía.

Eagle CAD

2. Para la impresión es importante que seleccionemos la opción “espejo” en la ventana de impresión ya que al pasar el diseño a la placa de cobre se vuelve a invertir, hacemos primero una copia sobre papel normal para posteriormente pegar con un poco de cinta adhesiva una proporción del transfer y volver a imprimir.

Esto por que algunas veces el costo del papel es elevado y de esta manera economizamos utilizando solo lo necesario. Lo recomendable es ajustar las propiedades de la impresora a la mayor calidad posible, para que adhiera la mayor cantidad de toner posible. Una vez tengamos la impresión, retiramos el papel transfer del normal y continuamos con la PCB
3. La placa de cobre no requiere ningún trato especial, únicamente hay que limpiarla muy bien para retirar posibles impurezas, en este ejemplo hemos utilizado una fibra y jabón para platos, algunos otros ejemplos en linea sobre este proceso recomiendan el uso de lana de metal o una lija de agua supongamos que también puede servir.

4. Planchar sobre la placa de cobre no es nada mas que poner el transfer sobre ella y literalmente planchar!, si el diseño de nuestro proyecto se adapto muy bien a una sola cara de la placa no implicara trabajo adicional, pero si no quedo mas remedio que hacerlo a dos caras, como es nuestro caso, nos llevara un poco mas de tiempo buscar la mejor alineación.

Algo que nos ha funcionado es poner cuatro puntos o señales adicionales al diseño para usarlos como guía, colocamos primero una cara del diseño (con el lado de la impresión hacia la placa de cobre) y la fijamos con un poco de cinta adhesiva, con ayuda de un taladro perforamos los cuatro puntos, y esto nos servirá para poder alinear la segunda cara. Hacer PCBs a doble cara no es un proceso sencillo precisamente por el problema de alinear las caras, si bien este tutorial parece fácil, créanme que hemos errado al menos dos veces antes del resultado esperado, aunque sin duda vale la pena 🙂 .

5. Ya que tengamos alineado el papel transfer y pegado en la PCB virgen, no queda mas que planchar. Recuerden que para los casos donde el proyecto requiera una sola capa, el proceso de alineación no es necesario. El tiempo aproximado de planchado es de 3 minutos con el calor de la plancha al máximo, es recomendable que si trabajamos sobre una mesa, coloquemos una prenda de algodón por debajo, para evitar quemaduras.

6. Se aprecia un poco cuando el toner se ha adherido al cobre, creo que después de un par de placas lo llegaran a notar sin problema. Ya que hayamos planchado hay que esperar un poco a que la placa se enfrié para posteriormente meterla en agua y esperar un tiempo a que el papel se empiece a deshacer o romper, aproximadamente 15 minutos.

7. Con ayuda de unas pinzas podemos empezar a desprender el papel de la placa, si todo a ido bien, tendríamos que estar viendo el 99% del toner pegado al cobre.

8. Algo que hacemos y que en lo personal me ha parece una mejor manera, es el perforado y corte de la PCB antes de “atacar” con acido, a diferencia de otros ejemplos que he visto, en ocasiones ya tienes tu PCB muy bonita y con las rutas bien marcadas cuando cometes un error al perforar donde no debías 😦 , lo que implica volver a realizar el proceso y gastar mucho mas acido, no por que sea costoso si no que es un elemento contaminante y si bien no lo podemos impedir pues al menos usemos lo menos posible.

9. Otra cosa que seguro será un obstáculo es el error en las pistas sobre el cobre, por lo que tendremos que corregir, para el caso donde no se haya pasado el toner suficiente podemos usar un marcador de tinta indeleble con punta fina y rayar sobre la parte necesaria, de manera que la parte de la pista faltante que cubierta de tinta, y para los casos donde haya toner de mas, podemos usar un x-acto para retirar el toner o la tinta adicional.

10. Ya que este lista nuestra PCB, cortada, perforada y con las correcciones necesarias continuamos con el atacado, lo mas común es usar 3/4 de cloruro férrico + 1/4 de agua, usando lo suficiente para cubrir totalmente la PCB.

11. Es importante estar moviendo constantemente el contenido, así se crea una mejor reacción y el cobre que no necesitamos será removido adecuadamente.

Dependiendo del tamaño de la placa, el tiempo de atacado puede variar, el truco esta mover constantemente y observar hasta que el cobre que no necesitamos haya desaparecido.

12. Una ves echo esto, será necesario lavar la placa con abundante agua hasta eliminar cualquier residuo de acido.

Para terminar podemos usar algún disolvente de pintura, como el utilizado para quitar el esmalte de las uñas (acetona o thinner ).

 

Y es todo!

Si bien el proceso no es el mejor, puede ser una muy buena opción para proyectos funcionales y que ocuparemos a manera de demostración o en un ambiente poco agresivo. El ultimo paso es agregar los componentes y soldar, que por cierto también se vuelve una habilidad después de un tiempo 🙂 .

Internet of Things, cuando las cosas conocieron Internet

Hoy en día la tecnología avanza y pareciera que nuestro vocabulario aumenta. Cada vez hay más palabras que parecieran que son una “moda” impuesta por las nuevas tendencias del mundo y a la vez otras palabras mueren. “Internet of things” o en español “Internet de las cosas” es un conjunto de palabras nuevo y que están moviendo al mundo a un lugar donde estará todo completamente conectado gracias a Internet. Muchas películas de ciencia ficción predecían un futuro donde nuestras ropas serán diferentes, los autos volarán y todos viviremos en plena armonía. Tal vez muchas de estas predicciones no se han hecho realidad o no en su mayoría pero la predicción que poco a poco se va haciendo realidad es que las posibilidades de que hablemos con nuestras cosas y electrodomésticos es cada vez más real gracias al “Internet of Things”.

“Internet of Things” también llamado “IoT” describe a un mundo interconectado no solo de personas sino también de dispositivos y no es algo que pasará en el futuro sino que está sucediendo en estos momentos. Y bien, IoT está creciendo cada ves más y más, pareciera que es inevitable y que mientras formemos parte de esta tierra seremos parte de esto y no podremos escapar. Cada vez existen más dispositivos electrónicos con capacidades y tecnologías Wi-Fi, Bluetooth y RFID. Estos dispositivos están siendo utilizados para recolectar datos, llevarlos a internet, analizarlos y tomar decisiones.

Internet of Things no es más que el siguiente paso lógico en la evolución de la conectividad masiva, pasando de conectar no solo personas sino también cosas. Y como no podemos escapar de esto sería mejor que entendamos mejor el concepto y veamos la forma en que esto nos afectará o nos beneficiará.

¿Qué es exactamente “Internet of Things”?

En estos momentos Internet es una plataforma en la cual millones de personas interactúan unas con otras en tiempo real, es decir Internet es una plataforma usada por humanos, personas que a diario quieren saber más, conocer su entorno, compartir ideas o simplemente hablar con una persona al otro lado del mundo. Sin duda hay demasiadas computadoras, cables, routers y más “cosas” que hacen posible esta comunicación pero al final del día la información es enviada y recibida por humanos.

Reflexionando un poco, ¿qué sería internet si humanos?, es decir, un periódico en linea sin editores, redes sociales sin usuarios, videojuegos sin gamers, Youtube sin creadores ni consumidores de contenido. Es casi imposible imaginar esa cantidad de Petabytes de datos siendo transmitidos de casi todo el mundo. Internet of Things crea un concepto aún más diferente, según CISCO el IoT hace referencia al punto en que hay más “cosas” u “objetos” que personas conectadas a Internet y como dato curioso esto sucedió en el 2008. Internet of Things también hace referencia a una red donde múltiples objetos están interconectados unos con otros e interactúan entre ellos sin la participación de humanos. Este tipo de comunicación dispositivo-dispositivo involucra una recolección de información, procesamiento y la toma de decisiones dependiendo de esta información.

Es importante recordar que casi cualquier objeto en el mundo genera información y la mayoría de esta información no es recolectada. Además no olvidemos de que todo puede ser medido: temperatura, luz, humedad, masa, velocidad, distancia, frecuencia, etc. Estos datos generan a su vez información y con esta información se puede generar conocimiento lo que crea mejor tecnología para mejorar nuestra calidad de vida.

¿Cómo funciona todo esto?

Bueno imagina que vas llegando a tu casa de la oficina o del trabajo, tu termostato inteligente detecta que vas a llegar a casa dentro de 10 minutos y hace mucho calor en tu habitación, en eso enciende el aire acondicionado para que cuando llegues este una temperatura adecuada. O imagina otro escenario, donde saliste con mucha prisa de tu casa y dejaste la luz prendida, pero gracias a que tus apagadores tienen conexión a internet podrás recibir una notificación a tu teléfono diciéndote que dejaste la luz prendida y podrás apagarla de manera remota. Imagina además miles de sensores de temperatura conectados a Internet, recolectando información certera e instantánea, toda esa información sería capaz de ser transmitida a centros de investigación donde se podrán utilizar para su análisis. ¿Ahora te das cuenta del impacto que esto tiene?

Además en la actualidad y en los próximos años podremos encontrar herramientas que nos ayuden a crear prototipos electrónicos conectados a Internet hechos por empresas que hace algunos años no existían y no había sospecha de ellos. Algunos ejemplos de estas plataformas de desarrollo son “Electric Imp” y “Spark” core, las cuales son pequeñas tarjetas de desarrollo que cuentan con un microcontrolador y antena Wi-Fi. Así que si quieres que tus proyectos tengan Wi-Fi puedes investigar más acerca de estas tarjetas de desarrollo las cuales (en mi humilde opinión) se harán muy populares en los próximos años.

Aún no conocemos realmente el impacto que todo esto tiene o que llegará a tener, un mundo de personas y dispositivos interconectados, cambiando grandes cantidades de infamación en instantes de tiempo para poder así tomar las decisiones más adecuadas. Bienvenido al internet de las cosas, no te sorprenda que ahora podrás compras una cafetera con Wi-Fi y no solo tu teléfono o computadora. Solo esperemos que todo esto se use de manera adecuada y para el beneficio de la humanidad.

Pequeños Proyectos con Attiny45/Attiny85

En cuantas ocasiones hemos tenido la necesidad de construir un pequeño proyecto basado en microcontrolador donde solo necesitamos un par de pines y las plataformas en el mercado nos resultas muy costosas para el producto que traemos en mente, por lo que solemos quedarnos en espera de una mejor solución para ponernos en practica, económica al menos.

La idea en esta entrega es enseñarnos a programar los pequeños microcontroladores ATtiny45 o ATtiny85 cargados con un bootloader de Arduino, tomando como referencia el tutorial elaborado por un equipo del MIT (ver aqui en ingles), quienes han echo un estupendo trabajo adecuando el firmware para poder trabajar con el pequeño microcontrolador y permitiéndonos cubrir las pequeñas y simples necesidad con el menor costo económico posible.

Los AttinyXX

Los microcontroladores ATtiny45 y ATtiny85 son algunos de los chips mas económicos y fáciles de usar que podemos encontrar en el mercado, sin embargo, al ser mas pequeño sus características, en comparación con el ATmega328 (Arduino UNO), también son algo reducidas. Para el ejemplo que veremos, estaremos usando solo el ATtiny85, por ninguna razón en particular, en teoría los dos chips mencionados deberían funcionar del mismo modo, veamos algunas características:

• Memoria Flash: 8Kb
• Memoria RAM: 512 bytes
• Memoria EPROM: 512 bytes
• Pines I/O: 6
• Frecuencia de operación (Max.): 8Mhz y hasta 20Mhz con cristal externo.
• CPU: 8-bit AVR

Como vemos su capacidad es bastante menor que la de un Arduino común, pero creo que suficiente para los pequeños proyectos que podemos construir. La diferencia con el ATtiny45, es que este viene con la mitad en memorias que el ATtiny85 y el costo es muy parecido, 2USD aproximadamente, así que por eso creo que el ATtiny85 es una mejor opción, aunque para mejor referencia pueden consultar la hoja de datos aquí.

¿Como hacerlo?

Bien! antes de empezar a grabar código en nuestro micro necesitamos un programador (ISP), existen varios dispositivos en el mercado que podemos usar, pero como estoy seguro que la mayoría de los que pasan por este blog tienen al menos un Arduino, nos inclinaremos por esta opción.

Podemos convertir nuestro Arduino en un programador ISP para grabar otros microcontroladores muy fácilmente, esto sin duda es otra de las grandes ventajas de esta plataforma, solo necesitaremos la versión del IDE 1.0.1 o superior. Una ves instalado y corriendo, abrimos el sketch en ejemplos “ArduinoISP”, ¡ojo! para los que vayan a usar Arduino UNO es necesario hacer una pequeña modificación cerca de la linea 112, dentro de la función “heartbeat()” cambiamos delay(40) por delay(20), seleccionamos la placa y el puerto correspondiente desde el menú Herramientas y subimos el sketch, y así de sencillo es como tendríamos listo un programador ISP para seguir 🙂

Ya que tenemos listo nuestro Arduino toca el turno al pequeño ATtiny, para continuar necesitamos agregar a nuestro entorno de desarrollo el soporte para este tipo de micros, que gracias al trabajo que ha echo el MIT lo podemos encontrar disponible para descarga:

Descargar (Github)

Lo agregamos/instalamos únicamente descomprimiendo el archivo descargado y copiando la carpeta contenida “attiny” a la dirección donde tengamos instalado nuestro IDE, tendría que quedar algo como Documentos > Arduino > hardware > attiny, si tenemos abierto el IDE lo reiniciamos y en el listado de Tarjetas tendríamos que ver algunas adicionales a las que están por default.

Con esto nuestro software estaría preparado para seguir, solo nos restaría la parte del hardware, donde ocuparemos la siguiente lista de componentes:

• Arduino UNO o Duemilanove (cualquiera con ATmega328)
• ATtiny85 por supuesto
• Capacitor de 10 uF (Para evitar el reset del Arduino al terminar de grabar)
• Led + Resistencia (Para la prueba)
• Protoboard
• Jumpers/Cables

Y tendríamos que conectar tal y como se muestra en el siguiente circuito:

De esta manera usaremos el Arduino a modo de programador ISP para cargar el sketch en nuestro pequeño micro, para hacer la prueba abrimos el ya clásico sketch de ejemplo “Blink” que viene con el software de Arduino y cambiaremos el valor del pin de 13 a 4, en el listado de tarjeta seleccionamos el microcontrolador a programar que en este caso es el ATtiny85 (internal 1 Mhz clock) y en la opción Herramientas > Programador seleccionamos la opción “Arduino as ISP” ya que es el que estamos usando, y por ultimo subimos el sketch…

Genial no?!, hay un par de cosas que tenemos que saber en relación al entorno, primero, al finalizar la carga del sketch aparecen en la consola de nuestro IDE los mensajes:

avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85
avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85

Esto es totalmente normal y no tendríamos que preocuparnos por ello, y segundo, en el ejemplo hemos seleccionado como Tarjeta la opción de 1MHz para el ATtiny85, para poder usar el chip a 8MHz seleccionamos esta opción en la lista de tarjetas y ejecutamos Menu > Grabar secuencia de inicio (“Burn Bootloader” si esta en ingles), no precisamente nos grabara el bootloader pero configurara de manera interna el ATtiny para correr a 8MHz, en teoría solo tendríamos que hacerlo una ves para cada chip que estemos utilizando y después solo bastaría con cargar el sketch normalmente.

En la imagen siguiente vemos el Pin Out del microcontrolador, en nuestro ejemplo hemos utilizado el Pin 4 dentro del código que corresponde al pin físico numero 3 del chip, podríamos hacer una prueba rápida con cada uno para familiarizarnos con la posición física y su numero correspondiente por código.

Según la información en el tutorial del MIT las siguientes funciones son soportadas para trabajarlas con los ATtiny, bastante bien creo yo, suficientes para buenas aplicaciones:

• pinMode()
• digitalWrite()
• digitalRead()
• analogRead()
• analogWrite()
• shiftOut()
• pulseIn()
• millis()
• micros()
• delay()
• delayMicroseconds()
• SoftwareSerial (has been updated in Arduino 1.0)

Plus: 

En el Vine se aprecia una placa casera en lugar de las conexiones en una Protoboard, es un prototipo que hicimos para no tener que conectar todo cada que necesitemos usar un ATtiny pero es prácticamente lo mismo y el diseño esta basado en el circuito de ejemplo, les dejo el Archivo para quien se anime a hacerla 🙂

Descargar

Pequeño Robot Móvil (Parte 2 – Programando los Motores)

En la lección anterior aprendimos un poco de los Robots, qué son, donde se usan y dimos la introdicción al pequeño Robot el cual vamos a estar construyendo en estas lecciones. En esa pequeña introducción hablamos de las partes de robot como lo son el chasis, los motores, el procesador, la batería, etc. En esta ocasión armaremos el primer circuito de nuestro robot, y programaremos sus motores y para eso vamos a necesitar un puente H modelo SN754410 como el que usamos en la lección 13 de Arduino. 

Primero que nada vamos a hablar de los motores para saber como es que se van a programar. Un motor es un dispositivo mecánico que genera movimiento rotacional a partir de energía , ya sea electríca (CD o CA), gasolina, gas, etc. Es muy común que ya estemos relacionados con este tipo de dispositivo ya que es muy usado en la actualidad, lo más común que podemos ver con motores son los autos. Para nuestro Robot vamos a utilizar un par de motores de corriente directa, esto significa que nuestro motores funcionarán con energía de baterías. Este tipo de motores empiezan a generar movimiento en el instante que le conectemos una batería. La forma en que conectemos la batería determinará el lado hacia el cual va a rotar. Inclusive para comprobar esto puedes intentarlo tu mismo, conectado una batería a un motor verás que gira hacia un sentido, si lo conectas la batería en sentido contrario verás como gira el motor en sentido opuesto.

Motor con batería conectada gira hacía un lado

Al cambiar el sentido de la batería gira hacia el otro lado

Puente H

Tal vez pudieramos hacer girar los motores de nuestro Robot con simplemente usar los pines de Arduino pero esto no sería lo correcto ya que el motor necesita mucho más potencia y podríamos terminar dañando al Arduino. Además de eso necesitamos controlar nuestro motor para que gire en ambos sentidos, es por eso que necesitaremos usar un Puente H como el que usamos en la segunda lección de motores con Arduino. Si quieres conocer más acerca del puente H te recomendamos leer la lección ya que aquí solo hablaremos de como armar el circuito para que funcione con nuestro Arduino y programar los motores.

Circuito

Una vez que tenemos todas las piezas de nuestro Robot (chasis, motores de CD, bateria, Arduino y puente H modelo SN754410 ) podemos empezar a armar nuestro primer circuito para nuestro pequeño robot móvil.

En la siguiente imagen podemos ver como es que está conectado el circuito. Como puedes ver 4 terminales van conecadas al Arduino y estas vienen del Puente H. Cada motor es controlado gracias a la señal de 2 de estas 4 lineas, es decir una linea controla la rotación hacia un lado y la otra linea controla la rotación hacia el otro lado. En el puende H podemos ver como se conectan los motores, no importa como conectes cada uno de los cables, después sabrás como controlar la polaridad.

Programación

Una vez terminada está conexión procederemos a programar nuestro Arduino para controlar los motores. El programa la verdad es que es algo sencillo ya que solo le mandamos las señales para que se mueve hacia uno de los lados.  Nota: Si al ejecutar el código no se mueven al mismo sentido solo tienes que cambiar la polaridad de alguno de los dos. No uses baterias de voltajes muy altos, lo recomendado es que sea de 12 volts y sobre todo que tus motores lo soporten.

	/*
	Configuracion de los pines de salida
	como podemos ver cada accion esta ligada
	a un pin, por ejemplo:
	la señal de atras del motor izquierdo esta ligado
	al pin dos del Arduino
	*/
	int atrasIzquierda = 2;
	int adelanteIzquierda = 3;
	int atrasDerecha = 4;
	int adelanteDerecha = 5;
	void setup(){
	//Configuramos todos los pines como salida
	pinMode(adelanteIzquierda, OUTPUT);
	pinMode(atrasIzquierda, OUTPUT);
	pinMode(atrasDerecha, OUTPUT);
	pinMode(adelanteDerecha, OUTPUT);
	}
	void loop(){
	//Mandamos la señal para que los motores giren
	digitalWrite(adelanteIzquierda, HIGH);
	digitalWrite(atrasIzquierda, LOW);
	digitalWrite(atrasDerecha, HIGH);
	digitalWrite(adelanteDerecha, LOW);
	}

view raw

puenteh

hosted with ❤ by GitHub

Video

View this post on Instagram

A post shared by Hardware Hacking Mx (@hardwarehackingmx)