Pantalla táctil 2,4"

Hola nuevamente, hoy les traigo unas pantallas del fabricante "mcufriend", el controlador es el SPFD5408. Me costó bastante encontrar las librerías y demás.
Cuenta con un lector de tarjetas micro SD y tiene una resolución de 240 x 320, son un poco lentas pero sirven para la mayoría de las aplicaciones.

Se puede conseguir en DX, al final después de las descargas les dejo el link.

En la librería se pueden encontrar algunos ejemplos muy claros de como funciona, con lo cual no es necesario poner algún ejemplo de mi parte, en la página "proyecto: integrador arduino" van a ver un ejemplo bastante interesante sobre como funciona.

En la carpeta de las librerías de la pantalla ("SWTFT-Shield") hay una carpeta que dice placas, dentro de ella se pueden encontrar 2 archivos, uno es para el arduino UNO y el otro para el mega. Esto es por la disposición de ciertos pines o definiciones de variables (lo corregí hace un tiempo largo ya, por lo que no recuerdo exactamente cual de las 2 cosas era). Para cambiar de placa solo hay que poner el archivo de la placa correcta, borrar lo que tiene en el paréntesis y cambiarlo por el SWTFT que está en la carpeta "SWTFT-Shield". Actualmente está puesto para hacerlo funcionar en un MEGA como se puede apreciar en las fotos de abajo.

Y ahora tienen un pequeño programa de ejemplo que viene con las librerías que es un "paint" en el cual se puede dibujar. Ese programa de ejemplo, en el arduino mega anda mal, está invertido el exe "x" y el eje "y", se podría modificarlo con la función map, pero como son los ejemplos "originales" decidí dejarlo como estaba

Descargas:

Pantalla:

https://mega.co.nz/#!H5gCzSiL!9PSVtEKC326hzOGqBiLbj_rzA-WvoyYP7OYyO4FoJvc


Donde comprar:

http://www.dx.com/p/diy-2-4-tft-lcd-touch-screen-shield-expansion-board-for-arduino-uno-350121

Assembler y arduino juntos.

Hoy les traigo algo interesante. Se trata de agregar porciones de código en assembler al arduino, esto se puede lograr colocando:

__asm__();

Ejemplo:

__asm__("nop\n\t");

Esto lo que hace es un nop (sería un "no operation"), con lo cual se pueden hacer delays de 1 ciclo máquina o dicho de otra forma se puede crear un delay (o tiempo de espera) de 62,5nS o 0,0000000625 segundos. 

Quizá todo esto pueda parecer un poco irrelevante, dado que esa cantidad de tiempo es imperceptible, pero a efectos prácticos se podrían desarrollar porciones de código que corran a una velocidad mayor o más precisamente, aunque como contra hay que aprender un lenguaje nuevo.

Acá les dejo un poco más de información sobre el tema (lamentablemente en inglés):

http://playground.arduino.cc/Main/AVR

https://www.arduino.cc/en/Reference/PortManipulation

http://www.nongnu.org/avr-libc/user-manual/inline_asm.html

módulo NRF24L01

En esta ocación voy a demostrar como se usan los módulos NRF24L01.

Se alimenta con 3,3V (es algo a destacar) pero tolera los 5V de un arduino como señal. Utiliza la interfaz "SPI" para comunicarse y tienen un bajo consumo (se consiguen los NRF24L01+ que tienen significativamente más potencia) que para trabajos de domótica son ideales, además de las librerías (que vienen con algunos ejemplos) les voy a dejar un programa mio que sirva para "chatear" entre 2 computadoras inalámbricamente a través del puerto serie que ofrece el ide de arduino. 

La librería que uso es la MIRF.

El chat es un programa simple, está pensado para comunicar un arduino nano y un mega

También les dejo unos programas para mandar y recibir datos fijos, además del chat en un archivo comprimido.

La idea es que descomenten las partes del código necesarios para el arduino mega o el nano

/*
  Este programa sirve para transmitir y recibir mensajes entre
  2 arduinos, el ejemplo este sirve para un arduino mega a un
  arduino nano. Descomentar según sea el caso.
  V2.5
*/

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

int incomingByte;
byte mensaje[33];

void setup(){
  Serial.begin(9600);

/*
  Mirf.cePin = 48;                          //para arduino mega
  Mirf.csnPin = 49;
*/

/*
  Mirf.cePin = 10;                          //para arduino nano
  Mirf.csnPin = 9;
*/

  Mirf.spi = &MirfHardwareSpi;
  Mirf.init();
  
/*
  Mirf.setRADDR((byte *)"mega");            //para arduino mega
  Mirf.setTADDR((byte *)"nano");
*/

/*
  Mirf.setRADDR((byte *)"nano");            //para arduino nano
  Mirf.setTADDR((byte *)"mega");
*/

  Mirf.payload = 1;
  Mirf.config();
}

void loop(){
  
  if (Serial.available() > 0)               //emisor 
  {
    Serial.print("yo -> ");
    char mensaje_letra;
    while (Serial.available())
    {
      incomingByte = Serial.read();
      mensaje_letra = incomingByte;
      Serial.print(mensaje_letra);
      Mirf.send((byte *)&incomingByte);
      while(Mirf.isSending());
      delay(3);
    }
    Serial.println(" ");
  }
  
  if(Mirf.dataReady())                      //receptor
  {
    Serial.print("el -> ");
    char mensaje_letra;
    int i = 0;
    byte c;
    while (Mirf.dataReady())
    {
      Mirf.getData(&c);
      mensaje[i] = c;
      mensaje_letra = mensaje[i];
      Serial.print(mensaje_letra);
      i++;
      delay(4);
    }
    i = 0;
    Serial.println(" ");
  }
}

Descargas:

Mirf:

https://mega.co.nz/#!e95mAbjQ!3IODmjbqTFaPyV-JfWrcHqYfgZ1kem02rLMNbO3gmKk

Ejemplos:

https://mega.co.nz/#!r1Rw2bCT!u_5bOL2ABX82iC9JWABd5Yka81zIK1WlKwuxrPdO5n8

Información extra:

http://playground.arduino.cc/InterfacingWithHardware/Nrf24L01

Comunicación serie

Acá les dejo un pequeño programa para hacer una comunicación serie en la cual se reciben datos por el puerto serie y se devuelven los mismos datos, de esta forma se pueden mandar datos al arduino por esta vía, este programa va a servir para el que voy a subir dentro de un rato.

char hola[33];
int primero = 0, i = 0, cantidad = 0;
void setup() {
  Serial.begin(9600);
}

void loop() {
  if (primero == 0)
  {
    Serial.println("ahora puede empezar a escribir");
    primero = 1;
  }
  while (Serial.available()) 
  {
    hola[i] = Serial.read();
    i++;
    cantidad = 1;
    delay(3);
  }
  
  i = 0;
  if (cantidad > 0)
  {
    for (int i = 0; i < 33; i = i + 1) 
    {
      Serial.print(hola[i]);
      hola[i] = 32;
    }
    Serial.println(" ");
    cantidad = 0;
  }
}

Sensor DHT 11, 22 y 21

Bueno, acá les dejo la librería del DHT, como se puede notar dunciona para las versiones 11, 21 y 22.

El módulo de la imágen es el "DHT 11" y si se mira de frente los pines son el gnd (se puede alimentar desde 3,3v hasta 5v), datos y positivo. No es una herramienta de precisión, porque tiene errores (teóricos) del 5% en humedad y 2ºC en temperatura.

Tiene un rango que va desde los 0ºC hasta los 50ºC.

En el ejemplo adjunto a la librería se puede ver cual es la programación que conlleva (muy sencilla), pero se la puede simplificar más aun.

Acá les dejo un sencillo programa para obtener los datos de temperatura y humedad

#include "DHT.h"
#define DHTPIN 22
#define DHTTYPE DHT11                                      
DHT dht(DHTPIN, DHTTYPE);

void setup () {

  Serial.begin(9800);
  dht.begin();

}

void loop () {

  int h = dht.readHumidity();
  int t = dht.readTemperature();

  Serial.print("temperatura: ");
  Serial.print(t);
  Serial.print("    humedad: ");
  Serial.println(h);
  delay(100);

}

El echo de declarar las variables como int, no influye casi, dado que no tiene la resolución necesaria para mostrar fracciones de grado.

Descargas:

DHT:
https://mega.co.nz/#!K0hi2YaC!Spubjr7ApxeBBqBSpDXeofYLQ9JDDn4AfqzeWCas4lA

Primera entrada

En este blog se van a compartir proyectos, programas, librerías y ejemplos de todo tipo, pueden estar relacionados con arduino o con electrónica en general.

Mi idea es ofrecer soluciones a problemas que haya tenido, proveer librerías probadas por mi y compartir proyectos para que ustedes puedan leerlos.