Confusion.com.mx

Estaba batallando un poco para convertir tipos de datos, y la verdad me constó un poco el caér en cuenta que pasar de flotantes a cadenas dentro del entorno de programación del arduino (avr-gcc) no era tan directo como creí.

Afortunadamente la respuesta vino de los propios foros de Arduino, del foro viejo para ser preciso.

La función mágina es dtostrf y según la documentacion de la biblioteca funciona así:

char* dtostrf( double         __val,
               signed char    __width,
               unsigned char  __prec,
               char *         __s
)

Facil, no…? Mejor una explicación simple:

char* dtostrf( double        variableFlotante,
               signed char  tamañoMinimo,
               unsigned char presicion,
               char          *cadenaDondeGuardar
)

Esta función recibe la variable que queremos convertir (variableFlotante), el tamaño mínimo de la cadena resultante (tamañoMinimo) incluyendo el punto decimal y el signo negativo en caso necesario, el número de dígitos tras el punto decimal (presicion) y una cadena con suficiente espacio para guardar (cadenaDondeGuardar). Regresa un apuntador a la cadenaDondeGuardar.

Y un pequeño código de ejemplo:

...
char cadenaTemporal[6];
double temperatura;

temperatura = leerSensorTemperatura();
dtostrf(temperatura, 5, 2, cadenaTemporal);
hacerAlgoCon(cadenaTemporal);
...

Cuando menos tengo que decir que fue interesante

Siguiendo con el trabajo de la entrada anterior y tratando de ir algo más lejos, la tarea de hoy es controlar el calefactor pero usando PWM para simular una salida analógica.

Seguimos teniendo la resistencia de 300 W, pero la restricción dice que NO podemos llevarla a disipar toda la potencia por el riesgo de quemar el calefactor. Bien, usemos un pulso con modulación (PWM) para usar una fracción de dicha potecia.

A grandes rasgos está bajo el siguiente esquema:

El optorelavador que se está usando es un Crydom ODC5, un componente bastante común. Según su hoja de datos, el tiempo máximo de activación es de 50 µs y el tiempo máximo de desactivación es de 100 µs. Medido en osciloscopio, el tiempo de activación ronda los 15 µs y el tiempo de desactivación esta por los 225 µs, los hemos cachado

Tiempo de activación.

Tiempo de desactivación.

En fin, para lo que deseamos es suficiente, ya que manejaremos a este relevador a una frecuencia de ~30 Hz.

Los puertos con salida PWM que tiene el arduino se manejan a una frecuencia de ~488 Hz, por lo que hay que modificarla para poder trabajar a lo que queremos, por que si no, el relevador siempre verá como encendido este puerto.

Lo siguiente lo voy a simplificar mucho y decir que en la función setup() hay que poner:

TCCR1B = TCCR1B & 0b11111000 | 0x05;

Con esa línea basta para modificar la frecuencia del pin PB5, lo que en el arduino Mega 2560 es equivalente al pin 11.

Ahora si se puede jugar con el PWM y cambiarle la potencia de entre 25 al 100%. Por alguna razón, no puedo bajarle más del 25%.

A seguirle con este interesante trabajo

Desde hace un tiempo tenia ganas de hacer este ejercicio, pero siempre le daba largas… hasta ahora

El funcionamiento es bastante simple, existe un sensor de temperatura AD7814 junto a una resistencia que funciona como calefactor, el arduino lee el sensor a travez de SPI y mantiene la temperatura del calefactor en un rango de 40 a 45 centígrados.


/** Control de temperatura usando arduino
* (c) 2011. Antonio Maldonado
* Esta obra esta bajo licencia Atribución-No comercial-Licenciamiento Recíproco 2.5
*/
#include

delay(1000);
}


Aún falta adecuarle el control PID y subir un par de videos más, pero lo voy poniendo el avance. Durante esta tarde que me ha llevado hacerlo (mas comida y juegos) voy contacto los progresos en twitter, así que esten atentos para la siguiente vez

Recuerdan la pelea entre Microsoft y Adafruit? Bueno, han salido una cantidad increíble de modificaciones y proyectos interesantes usando este dispositivo, haciendo cambiar de parecer a MS en el camino. Pero sin lugar a dudas, uno de los mejores es el NAVI (Ayuda de navegacion para débiles visuales) desarrollado en la Universidad de Konstanz.

Usando un Kinect montado en un casco, un arduino y tres motores en una especie de faja, fueron capaces de crear un sistema que ayuda a un invidente a caminar sorteando obstáculos.

Si bien la manera en que resuelven la montura es poco elegante, es muy práctica al igual que el funcionamiento con los motores.

Un sistema muy barato que puede hacer mucho por las personas, genial!

El viernes pasado se publicó finalmente un video que la comunidad de Arduino estaba esperando con ansias. “Arduino, El documental” explica a travez de entrevistas lo que fué el nacimiento de esta placa y es contada por sus creadores y personajes importantes en el mundo de la electrónica de “amateurs”.

Un material histórico muy interesante. Les recomiendo que lo vean, saludos!

Recursos

Página oficial: http://www.archive.org/details/Arduino.TheDocumentary.English

Blog de oficial arduino: http://arduino.cc/blog/2011/01/07/arduino-the-documentary-now-online/

Para bajar en Ingles: http://www.archive.org/details/Arduino.TheDocumentary.English

Para bajar en Español: http://www.archive.org/details/Arduino.TheDocumentary.Spanish

Sinceramente pensé que me llevaría más tiempo hacer cosas interesantes con el nuevo juguete, pero lo encuentro realmente fácil, si bien no soy nuevo en el área de la electrónica, si estoy muy lejos de ser un experto.

El proyecto de esta ocasión es el conectar una pantalla LCD con interfaz paralela basada en el controlador Hitachi HD44780 al Arduino. Como en estos casos, primero hay que ver el código que ya está hecho para poder entender y adaptar a las necesidades. El código base lo tomé de los ejemplos de LiquidCrystal, los que vienen incluídos con el Arduino.

El circuito, bastante sencillo por cierto, es como aparece aquí:

(presiona para ver más grande)

Creo que lo normal es encontrarselas en formatos 16×2 caracteres, aunque la que conseguí es de 20×4, no hubo mayor problema al conectarla. La interfaz serie consta de 16 líneas que se explican en su hoja de datos. He aquí una breve explicación de ellos:

1. Tierra.
2. Vcc (+5 V)
3. Ajuste de contraste (0 a 5 V)
4. Selector de registro (R/S)
5. Lectura escritura (R/W)
6. Reloj (habilitado)
7. Bit 0
8. Bit 1
9. Bit 2
10. Bit 3
11. Bit 4
12. Bit 5
13. Bit 6
14. Bit 7
15. Luz trasera (+)
16. Luz tarsera (-)

Nótese que marqué los bits 4 al 7, ya que con tan sólo con estos cuatro se puede mandar texto a la pantalla. El código es algo así

/*
 Biblioteca LiquidCrystal
 Hola mundo con control de contraste

 Demuestra cómo funciona una pantalla de cristal líquido en base al
 chip Hitachi HD44780 con interfaz paralela de 16 contáctos.

 Bibioteca agregada originalmente el 18 Apr 2008 por David A. Mellis
 Modificada el 2009-07-05 por Limor Fried (http://www.ladyada.net)
 Ejemplo agregado el 2009-07-09 por Tom Igoe
 Modificado el 2009-07-25 por David A. Mellis
 Modificado en 2010-04 por Antonio Maldonado (http://www.confusion.com.mx)
*/

//Incluír la biblioteca:
#include <liquidcrystal .h>

//Inicializa la biblioteca con las terminales adecuadas
LiquidCrystal LCD(7, 8, 9, 10, 11, 12);
int estadoBt1 = 0;
int estadoBt2 = 0;
int contraste = 100;

void setup() {
  //Configura el tamaño del LCD en filas y columnas
  LCD.begin(20, 4);

  //Se usa la terminal 6 para manejar el voltaje de la luz de contraste
  pinMode(6,OUTPUT);
  analogWrite(6,contraste);

  //Dejamos que el cursor parpade
  LCD.blink();

  //Para los botones que regularan el contraste
  pinMode(5,INPUT);
  pinMode(4,INPUT);
}

void loop() {
  //Si el botón 1 está activado, se sube el contraste aumentando el voltaje
  if( estadoBt1 == LOW && digitalRead(4) == HIGH ) {
    estadoBt1=HIGH;
    contraste++;
  } else {
    estadoBt1 = LOW;
  }

  //Si el botón 2 está activado, se baja el contraste reduciendo el voltaje
  if( estadoBt2 == LOW && digitalRead(5) == HIGH ) {
    estadoBt2 = HIGH;
    contraste--;
  } else {
    estadoBt2 = LOW;
  }

  //Limpia la pantalla
  LCD.clear();

  //Ajusta el voltaje para el contraste
  analogWrite(6,contraste);

  //Se hace el despliegue de los mensajes
  LCD.println("Hola mundo!");
  LCD.print("Contraste: ");
  LCD.print(contraste);

  //Un pequeño retardo y seguimos.
  delay(150);
}

Por el momento es todo, que se diviertan!

Recursos

Biblioteca oficial: http://arduino.cc/en/Tutorial/LiquidCrystal
Sobre botones pull-down: http://www.ladyada.net/learn/arduino/lesson5.html

No me hiba a quedar con las ganas de hacer algo con Arduino y acabo de recibir la placa Duemilanove

Aún no tengo tantos componentes como para hacer algo interesante, pero al menos pude hacer mi “hola mundo”. Este sencillo programa envía una señal de auxilio en clave morse: SOS (· · · — — — · · ·) usando el led integrado en la placa. El código original es parte de los ejemplos que viene con el IDE. Además, el programa envía el mensaje a la computadora usando el USB.

No es nada elaborado, simplemente quería hacer algo rápido

/* Blink Modificado. Envía una señal SOS en código morse
El circuito:
* un LED conectado del pin digial 13 a tierra.
* Nota: Al menos en la placa Duemilanove viene con el LED integrado
Creado en 1 Junio 2005 por David Cuartielles
Modificado 2010-03-31 por Antonio

http://arduino.cc/en/Tutorial/Blink

based on an orginal by H. Barragan for the Wiring i/o board
*/

int ledPin =  13;    // LED connected to digital pin 13
int contador = 0; //Se usa para calcular el mensaje SOS

// El método setup() se ejecuta una sola vez al inicio del programa
void setup()   {
  // Se inicializa el pin digital como SALIDA:
  pinMode(ledPin, OUTPUT);
  //Se comienza la transmisión serie
  Serial.begin(9600);
}

// El método loop() method runs over and over again,
// as long as the Arduino has power
void loop() {
  if((contador > 2) && (contador < 6) ) {
    digitalWrite(ledPin, HIGH); //Prende el LED
    delay(400);                //Se espera 400 ms
    digitalWrite(ledPin, LOW); //Apaga el LED
    delay(400);                //Se espera 400 ms
    Serial.print("-");         //Imprime el guión
  } else {
    digitalWrite(ledPin, HIGH); //Prende el LED
    delay(150);                //Se espera 150 ms
    digitalWrite(ledPin, LOW); //Apaga el LED
    delay(150);                //Se espera 150 ms
    Serial.print(".");         //Imprime el punto
  }

  Serial.print(" "); //Despues de cada caracter pone un espacio dentro de la transmisión serie
  contador++; //Suma 1 al contador
  if(contador == 9) { //Si el mensaje terminó, reinicia el contador y espera dos segundos para repetirlo
    contador = 0;
    delay(2000);
    Serial.println(" "); //Pasamos a la siguiente línea en la transmisión
  }

  if((contador % 3) == 0) //Hace una pequeña pausa entre letra y letra
  delay(400);
}

Recursos

Primeros pasos: http://www.ladyada.net/learn/arduino/

Arduino es una verdadera plataforma de hardware abierto que permite desarrollar proyectos de electrónica de una manera muy fácil. rápida y de bajo costo.

Caracteristicas principales

El sistema es bastante sencillo, consta de una placa con un microcontrolador integrado, puertos de entrada y salida digital y analógos; se programa usando un IDE y su lenguaje es “Wiring”; se conecta a la computadora usando una entrada USB que está en la tarjeta y se alimenta con 9 v. Sencillo, no?

Para los amantes de la electrónica, pueden ver la página donde estan todas las variantes para conocer los datos técnicos de ellas.

Módulos interesantes

• Compás
• Una placa miniatura
• Interfaz ethernet
• Pantalla táctil
• Red wifi

¿Donde comprar?

Dentro de la página del proyecto pueden ver los distribuidores mundiales, así siempre pueden encontrar uno cerca

La placa Duemilanove ronda los $30 USD, aquí en México la puedes adquirir por $500 MXN

Más información

• Página principal: http://arduino.cc/en/Main/HomePage
• Ejemplo de muchos proyectos: http://www.freeduino.org/index.html
• DuinOS, un sistema operativo para tiempo real: http://www.multiplo.org/duinos/wiki/index.php?title=Main_Page