jueves, 29 de septiembre de 2016

Driver nRF24L01 para arduino

En el post anterior vimos como conectar correctamente los pines del nRF24L01 y los Arduinos Nanos y Mega2560. La conexión de los pines pueden variar dependiendo de la configuración del driver. Pero la que usé en mi ejemplo, es casi como un "estándar", ya que ví varios ejemplos de otros desarrolladores, que lo configuraban como yo.

Vamos a ver las partes más importantes del driver.

En primer lugar en el archivo nRF24L01_RegisterMap.h se encuentra la declaración de los registros del módulo.


Lo primero que se debe hacer, en el main es llamar a la función rf_init() para inicializar el módulo.

1:  //inizialize rf tx   
2:  rf_init();  

Está función hace lo siguiente:

Lo que hace es setear como salida los pines CE y CSN definidos en nRF24L01_RegisterMap.h. Luego pone en cero CE y en uno CSN

Paso siguiente se llama a la función rf_config() en el cual se pasa como parámetro el canal de transmisión más el ancho del payload. Esta función realiza una serie de configuraciones necesarias y básicas para poder funcionar. Y luego se setea en modo RX, para que el módulo se ponga a escuchar.


Es importante setear correctamente las direcciones. Para el transmisor se utiliza las sigiuentes direcciones:

1:  uint8_t tx_address[5] = {0xE7,0xE7,0xE7,0xE7,0xE7};/**<Dirección del transmisor*/  
2:  uint8_t rx_address[5] = {0xD7,0xD7,0xD7,0xD7,0xD7};/**<Dirección del receptorr*/  

En el caso del receptor las direcciones son las siguientes:

1:  /*define addr*/  
2:  uint8_t tx_address[5] = {0xD7,0xD7,0xD7,0xD7,0xD7};  
3:  uint8_t rx_address[5] = {0xE7,0xE7,0xE7,0xE7,0xE7};  

Para ello se utiliza las siguientes función:

1:  //set the device addr  
2:  set_rx_address(rx_address);  
3:  set_tx_address(tx_address);  

Notese que las direcciones están cruzadas.

Transmisor

El código del transmisor se muestra a continuación.


Receptor

El código del receptor se muestra quedó de la siguiente manera.



En post posteriores se moestrará más detalle del código del módulo. Y se buscará complejizar el código.

El código del transmisor se lo puede descargar de aquí. Mientras que al código del receptor se lo descarga desde aquí.

miércoles, 28 de septiembre de 2016

Lenguajes de programación esotéricos

Los lenguajes de programación esotéricos, son lenguajes minimalistas, de naturaleza ofuscada u otra característica que no es común en otros lenguajes de programación. Se suelen usar como prueba de concepto en la creación de lenguajes de programación Turing completos. Poseen una sintaxis muy básica. Estos lenguajes suelen ser creados por simple diversión, ya que difícilmente sean  implementados en proyectos. Sin embargo, se trata de un lenguaje que funcionan como desafío tanto para quienes lo crean, como para aquellos que intentan programar con ellos (Wikipedia).

Existe una wiki, llamada esolangs dedicada a la promoción y documentación de estos lenguajes raros.

Algunos lenguajes esotéricos

Brainf*ck

Este ese el más conocido de estos lenguajes. Fue diseñado por Urban Müller en 1993, con el objetivo de crear un lenguaje simple, turing completo y que requiera de un compilador pequeño.

Aquí se puede ver un ejemplo del famoso "Hola Mundo"

Ook!

Está basado en brainf*ck, pero utiliza en su lugar la combinación de palabras Ook?, Ook! y Ook. Es una parodia del bibliotecario de Mundodisco, que es transformado en orangután y solo puede pronunciar esas tres palabras.

A continuación se observa el ejemplo del "Hola Mundo"


Qriollo

Qriollo es un lenguaje de programación esotérico argentino. El compilador de Qriollo está desarrollado en Haskell, tiene múltiples backends, y puede generar código C, código Python, y bytecode para la JVM. La implementación se encuentra en fase inestable/experimental y cuenta con una interfaz de funciones gringas.

Tiene las funcionalidades usuales de un lenguaje de programación de la familia de ML: tipos de datos algebraicos, análisis de casos por comparación de patrones, clausuras léxicas, optimización de invocaciones a la cola, referencias mutables y call/cc.



martes, 27 de septiembre de 2016

nRF24L01 usando arduino (AVR) II

En el post anterior di una muy breve introducción al módulo nRF24L01. En esta oportunidad daré un poco más de detalle sobre cómo conectar el módulo a los Arduinos.

Antes de continuar se debe indicar que este será usado en el desarrollo de un Drone (quadcopter) casero. El control remoto (Arduino Nano - atmega328p) y el drone en sí mismo (Arduino Mega - atmega2560) se comunicarán por radio frecuencia (RF), usando este módulo.

 

 Pines del nRF24L01+

El módulo tiene 8 pines. 
  1. GND
  2. VCC
  3. CE
  4. CSN
  5. CSK
  6. MOSI
  7. MISO
  8. IRQ

Pines nRF24L01+


VCC siempre tiene que conectarse a 3.3V.
 
La conexión al Arduino Nano es la siguiente:
GND   ->  GND
VCC    ->  3.3V
CE      ->  D9
CSN   ->  D10
SCK   ->  D13
MOSI ->  D11
MISO ->  D12
IRQ    ->  No usado


Arduino Nano + nRF24L01



 Por otro lado tenemos el Arduino Mega conectado de la siguiente manera:

GND   ->  GND
VCC    ->  3.3V
CE      ->  9
CSN   ->  53
SCK   ->  52
MOSI ->  51
MISO ->  50
IRQ    ->  No usado

Arduino Mega + nRF24L01

El código del Arduino Nano (transmisor) se lo puede descargar desde aquí.

El código del Arduino Mega (receptor) se lo puede descargar desde aquí.

En el siguiente post se explicará las principales partes del código.

lunes, 26 de septiembre de 2016

nRF24L01 usando arduino (AVR) I

El nRF24L01 es un tranceiver de 2.4Ghz con un protocolo embebido (Enhanced ShockBurst™). Este se suele utilizar en aplicaciones wireless de bajo consumo. En este caso será utilizado en la comunicación con un Drone.


Resultado de imagen para nrf24l01



Para controlar el chip se utiliza SPI (Serial Peripheral Interface). Los registros son accedidos mediante SPI.

El radio usa modulación GFSK. Este tranceptor tiene parámetros configurables como el canal de frecuencia, power de salida, air data rate (250kbps, 1Mbps, 2Mbps).

La idea de este pequeño proyecto es enviar datos desde un arduino Nano a un arduino Mega, mediante este tranceptor y utilizando el lenguaje C.

Se puede encontrar más información en el datasheet del módulo

domingo, 25 de septiembre de 2016

Blink Led Arduino usando C

En mi primer Post en este Blog, voy a mostrar un proyecto simple. El "Hello Word" de Arduino, pero escrito en C.

Tenemos un entorno en eclipse más el toolchain de AVR.

El código es bastante simple.

En primer lugar definimos las bibliotecas que vamos a utilizar:

#include <avr/io.h>
#include <util/delay.h>


Definimos un MACRO que define el F_CPU, la cual es una manera de indicar cuán rápido está corriendo el MCU.

#define F_CPU 16000000UL

Siguiente paso definimos una función denominada configHardware(), la cual define el pin 13 del arduino Mega como salida:

DDRB |= (1<<PORTB7)

Por último se define el main. Se coloca todo en while infinito. Y se utiliza

PORTB |= (1<<PORTB7) ;

Para prender el led. Y:

PORTB &= ~(1<<PORTB7);


Para apagarlo.


La siguiente lína es un delay de 100 microsegundos.

_delay_ms(100);


Una vez terminado el código queda como sigue:


Compilamos y programamos el arduino y listo.


Dejo el repositorio del ejemplo para decargarlo:

Ejemplo BlinkLed en GitHub