SERVIDOR WEB AVANZADO UTILIZANDO WIFI SHIELD CON SD Y ARDUINO.

Tras algunas pruebas satisfactorias en las que he probado los ejemplos básicos de creación de una página web muy sencilla  hecha con dreamweaver y grabada en la tarjeta SD de la wifi shield, me he dado cuenta que las cosas se complican si deseo crear páginas más complejas con las que controlar de manera elegante el arduino.

Es decir, los códigos se complican en tamaño y densidad si deseo realizar un servidor WEB que muestre una web detallada con colores, tipos y fuentes de letra variados, gráficos, organización de elementos,etc. Esto lo podriamos abordar con CCS pero además el problema es que este servidor WEB va a tener parametros de entrada y salida, como controles para encender o apagar leds, interruptores, sensores de todo tipo,etc y mis conocimientos de programacion web a pelo (html,ajax,ccs) son de andar por casa; de hecho en mi viejos tiempos todo lo hacia con dreamweaver,fireworks y software por el estilo que me abstraia de lo que era el código puro y duro de la web.

Por tanto, el tema se complica. Esta claro que para diseñar un servidor web un poco profesional necesito entender mucho más la programación web y ahondar en el tema de la intercomunicación interna entre el código subido a mi arduino y el código web que interpreta el navegador. Y esto no se puede realizar con atajos visuales tipo "wysiwyg". Es imprescindible tocar teclado y programar html a pelo.

Por ello y en espera de la parte de material que me falta de la impresora 3d, me pondré las pilas y empezaré, con taza de café en mano, a visionar los estupendos videotutoriales que la casa "videobrain" tiene al respecto de la programación web y a  ver si saco algo en claro....

COMO MONOTORIZAR TEMPERATURAS EN PACHUBE CON ARDUINO UNO Y ARDUINO SHIELD ETHERNET (PARTE 2)

Ahora vamos a ver el centro de la cuestión. Examinaremos el código que debemos cargar en nuestro arduino. Y aunque en la página de pacube/cosm tenemos unos estupendos ejemplos con arduino explicados, claro esta, en perfecto inglés, nosotros utilizaremos una librería que nos va a simplificar mucho las cosas, "escondiendo" la parte del código más dificil de entender.

Por otra parte, en la pagina oficial de arduino tambien disponemos de una explicación detallada de la comunicación con pachube/cosm:  http://arduino.cc/en/Tutorial/PachubeCient. Incluso las últimas versiones del IDE de arduino ya traen ejemplos integrados de esto como se puede ver con la versión 1.5.2 en la siguiente figura:

Asi que nos vamos a el siguiente repositorio y nos bajamos la librería en custión: 

http://code.google.com/p/pachubelibrary/

 La tenemos en la opción "downloads": ERxPachube-I-3.2.zip.

Después de ello la descargarmos en el subdirectorio "libraries" de la carpeta arduino, con lo cúal al abrillo ya tendremos el ejemplo "PachubeOut" disponible, que debemos modificar para personalizarlo de acuerdo con nuestras necesidades.

El Código modificado es el siguiente:

/*
Pachube Data Out

Demuestra el uso de la librería ERxPachube
Sube datos de temperatura al servidor  Pachube/cosm.
 
Primero en registráte en  (http://www.cosm.com/).

Para correr este sketch, necesitamos:

 1. Crear un  propio " feed" o fuente de datos
 2. Usar  tú propia  "API key" y remplázala donde pone: PACHUBE_API_KEY.
 3. Usa tú propia "feed "  y remplázala donde pone: PACHUBE_FEED_ID.

Circuit:
* Ethernet shield attached to pins 10, 11, 12, 13

* Created 22 April 2011
* By Jeffrey Sun
* http://code.google.com/p/pachubelibrary/

*/
#include <Arduino.h>
#include <HardwareSerial.h>
#include <ERxPachube.h>
#include <Ethernet.h>
#include <SPI.h>


byte mac[] = { 0x90, 0xA2, 0xDA, 0x0D, 0xF4, 0x61 };
 // Aquí podemos la MAC de nuestra shield Etrhenet
 
byte ip[] = { 192, 168, 0, 15 };           
 // Aquí podemos la IP asignada por nuestro Router( en este mi Vodafone)

#define PACHUBE_API_KEY                "ngJ6D7RYoZCc3LwiF175iBGIppCSAKx3eGdMdGVhL2hhdz0g" 
// Aquí pondemos la API key PACHUBE_API_KEY

#define PACHUBE_FEED_ID                "126168" 
// Aqúi ponemos el identificador de temperatura (FEED)  de nuestro arduino

ERxPachubeDataOut dataout(PACHUBE_API_KEY, PACHUBE_FEED_ID);

void PrintDataStream(const ERxPachube& pachube);

void setup() {
       
       
    Serial.begin(9600);
    Ethernet.begin(mac, ip);

    dataout.addData(0);
    //dataout.addData(1);            // Lineas comentadas porque solo tenemos un FEED
    //dataout.addData(2);
}

void loop() {

    Serial.println("+++++++++++++++++++++++++++++++++++++++++++++++++");
    //float fSensorData = 15.23;
        float tempC;
        int tempPin = 0;
        tempC = analogRead(tempPin);
        tempC = (5.0 * tempC * 100.0)/1024.0;
       
    dataout.updateData(0, tempC);
    //dataout.updateData(1, fSensorData);    // Lineas comentadas porque solo tenemos un FEED
    //dataout.updateData(1, "Arduino Data");

    int status = dataout.updatePachube();

    Serial.print("sync status code <OK == 200> => ");     // Sólo para propósitos de DEBUG
    Serial.println(status);

    PrintDataStream(dataout);                   //Enviamos el dato de temperatura

    delay(5000);
}

void PrintDataStream(const ERxPachube& pachube)
{
    unsigned int count = pachube.countDatastreams();
    Serial.print("data count=> ");
    Serial.println(count);

    Serial.println("<id>,<value>");
    for(unsigned int i = 0; i < count; i++)
    {
        Serial.print(pachube.getIdByIndex(i));
        Serial.print(",");
        Serial.print(pachube.getValueByIndex(i));
        Serial.println();
    }
}

En el siguiente video explico como conseguir la PACHUBE_API_KEY y la PACHUBE_FEED_ID 

necesarias para comunicar el arduino con el servidor pachube/cosm.

http://www.youtube.com/watch?v=wyKyHcsXYSE

Fotos diversas del proyecto:

COMO MONOTORIZAR TEMPERATURAS EN PACHUBE CON ARDUINO UNO Y ARDUINO SHIELD ETHERNET (PARTE1)

En este proyecto vamos a "subir" las temperaturas medidas con un sensor LM35 a la "nube"; en concreto al servidor y colector de datos llamado pachube (ahora https://cosm.com/) y poder visualizar un histórico de las mismas desde cualquier ordenador que tenga conexión a internet. Es lo que ahora se conoce como INTERNET DE LAS COSAS.  Para este proyecto necesitamos lo siguiente:

.-. Un Arduino UNO rev3.

.-. Una Ethernet Shield para Arduino.

.-. Un sensor de temperatura analógico LM35.

.-. Un Router con conexión a Internet y alguna boca Rj45 libre. (el que tengo en mi casa vale perfecto).

La idea es simple pero preciosa. Mido la temperatura en el salón de mi casa, subo cada cierto tiempo y de forma automática mediante arduino este dato a la página de pachube, y en cualquier momento, y desde cualquier lugar,  puedo observar el  historico de esos valores utilizando un ordenador con conexion a internet.

Comenzamos con lo más sencillo que es la configuración de mi router para que "entienda" mi arduino con su ethernet shield montada.

En las siguienes figuras podeís observar el hardware montado:

El el siguiente video explico como he configurado el router de mi casa, que en este caso es de VODAFONE, pero que puede se puede aplicar a otro de otra compañia. Tambien explico los aspectos generales del servidor-colector de datos denominado PACHUCE/COSM y como utlizarlo para nuestros propósitos.

http://www.youtube.com/watch?v=M83od48TTJE

CONTROL DE UN MOTOR PASO A PASO BIPOLAR INALÁMBRICAMENTE (XBEE) CON ARDUINO Y LABVIEW (4º parte)

En última parte del proyecto veremos como añadir la shield XBee encima de la shield motor que a su vez está sobre el arduino uno. Es decir tenemos dos shields encima del arduino y observamos que no tenemos incompatibilidad de pines ya que la shield XBee sólo utliza las patillas implicadas en la trasmismión serie. Pero a nivel hardware tenemos un problema de compatibilidad que hemos solucinado de la siguiente manera.

Las dos shields apiladas sobre el arduino.

Como se oberva en esta última figura de canto la alimentación de la XBee no llega a la placa arduino, por lo que he tenido que hacer un apaño de soldar unos cables a un trozo de regleta (gracias a Nicolás del 1º del ciclo superior de mantenimiento electrónico porque mi vista ya no es lo que era).

 

Ahora el conjunto funciona perefectamente. En cuanto al programa en labview simplemente hay que cambiar la entrada serial/USB por la opción XBEE y listo.

Esto lo podemos observar en el último video:

http://www.youtube.com/watch?v=oFl85qnZuTM

CONTROL DE UN MOTOR PASO A PASO BIPOLAR INALÁMBRICAMENTE (XBEE) CON ARDUINO Y LABVIEW (3º PARTE)

En esta fase del proyecto nos centraremos en el LABVIEW y su programación. Principalmente, en los bloques referentes al ARDUINO que manejan los motores paso a paso. Ya que no soy ni mucho menos , un programador experimentado en el lenguaje de programción G de Labview, mostraré un ejemplo muy sencillo en el que aparecerán los bloques imprescindibles que necesito para realizar un control básico del motor. La verdad es que no hay mucha documentación sobre este tema y todo lo que he hecho se basa en mi propia experimentación.

Si quisieramos desarrollar ejemplos más completos,evidentemente,no sería problema añadir bloques y funciones más complejos de los que dispone Labview para ampliar lo aquí expuesto.

En el siguiente video explico un ejemplo básico de gobierno de un motor paso a paso bipolar en el que defino el número de pasos que gira así como la velocidad a lo que lo hace.

http://www.youtube.com/watch?v=AHPQvV_AkqY

Aquí os dejo el vi (programa que muestro en el video)  para labview:

https://www.dropbox.com/s/gj4un44vt7dltcs/motorpasoapaso.vi

CONTROL DE UN MOTOR PASO A PASO BIPOLAR INALÁMBRICAMENTE (XBEE) CON ARDUINO Y LABVIEW (2º PARTE)

En esta 2º parte de éste proyecto vamos a utilizar la librería stepper.h que proporciona arduino para el gobierno sencillo de motores paso a paso:

/*
 Stepper Motor Controller
 language: Wiring/Arduino

 This program drives a unipolar or bipolar stepper motor.
 The motor is attached to digital pins 8 and 9 of the Arduino.

 The motor moves 100 steps in one direction, then 100 in the other.

 Created 11 Mar. 2007
 Modified 7 Apr. 2007
 by Tom Igoe

 */

// define the pins that the motor is attached to. You can use
// any digital I/O pins.

#include <Stepper.h>

#define motorSteps 200     // change this depending on the number of steps
                                         // per revolution of your motor
#define motorPin1 13
#define motorPin2 12


// initialize of the Stepper library:

Stepper myStepper(motorSteps, motorPin1,motorPin2);

void setup() {
  // set the motor speed at 60 RPMS:
 
  const int pwm_cha = 3;
  const int pwm_chb = 11;
  pinMode(pwm_cha, OUTPUT);
  pinMode(pwm_chb, OUTPUT);
  digitalWrite(pwm_cha, HIGH);
  digitalWrite(pwm_chb, HIGH);
   
  myStepper.setSpeed(100);

                                                         // Initialize the Serial port:
  Serial.begin(9600);

}

void loop()
{
  Serial.println("En un Sentido");
  myStepper.step(200);
  delay(500);

  Serial.println("En el otro");
  myStepper.step(-200);
  delay(500);
}

En el video que figura a continuación explico básicamente como funciona el programa y lo que debes modificar para adecuarlo al tipo de motor paso que tengas:

http://www.youtube.com/watch?v=KSfRjcf1JTk

CONTROL DE UN MOTOR PASO A PASO BIPOLAR INALÁMBRICAMENTE (XBEE) CON ARDUINO Y LABVIEW (1º PARTE)

En este proyecto abordaré el tema de los motores paso paso y su control desde arduino. En un paso final gobernaré dicho motor desde XBEE y LABVIEW con un panel frontal muy chulo.

El Motor paso a paso que voy a cotrolar es bipolar y consta de 4 hilos. Cada par de ellos gobierna una bobina. En la foto vemos dicho motor:

 

Este es un motor paso a paso Bipolar 35x36mm de 200 pasos por vuelta. Cada fase funciona a 2.7V a 1000mA lo que le proporciona un torque de 1400g-cm. Pesa tan solo 180 gramos y es de dimensiones muy reducidas.

Especificationes:

• Tamaño: 35x36 mm (sin contar el eje)
• Peso: 180 gramos
• Diámetro del eje: 5 mm
• Corriente: 1000 mA por fase
• Voltaje: 2.7 V
• Longitud del eje: 15 mm (diámetro: 4mm)
• Resistencia: 2.7 Ohm por bobinado
• Torque: 1400 g-cm (2.5 oz-in)
• Pasos por vuelta: 200

En esta estupenda página disponemos de un tutorial my clarito que explica la teoría de dichos motores:

http://www.monografias.com/trabajos37/motores/motores.shtml

Nosotros en canbiio vamos a controlar el motor mediante una librería muy sencilla disponible para arduino y para la tarjeta de control de dicho motor llamada: Arduino Motor Shield Rev3.

Esta shield tiene dos canales separados, denominados A y B, que cada usa 4 de los pines de Arduino para conducir y sensar el motor. En total hay 8 pines en su uso . Se puede utilizar cada canal por separado para conducir dos motores DC o combinarlos para conducir un motor paso a paso. Las Cables de la figura deben conectarse bien a la placa según el par de bobinas o según los colores que se indican. Bobina 1 (cables azul y rojo).Bobina 2 (Cables negro y azul).Mirar las caracterisiticas de tu motor si los colores son diferentes.

Los Pins de la shield, dividido por el canal se muestran en la siguiente tabla:
 

Function	pins per Ch. A	pins per Ch. B
Direction	D12	D13
PWM	D3	D11
Brake	D9	D8
Current Sensing	A0	A1

Además tiene dos pines de alimentación exterior para el motor a los cuales conectaremos una pila de 9 Voltios. Los Pines de "Brake" y "Current Sensing" nos los utilizaremos.

 

 Si no hacemos uso de la librería el programa bajo Arduino que haría girar el motor en un sólo sentido con la secuencia apropiada aplicada a las dos bobinas sería el siguiente:

// Programa simple de giro continuo del motor bipolar (sólo para pruebas)

int motorPin1 = 13;       // pines del Motor
int motorPin2 = 12;
int motorPin3 = 3;
int motorPin4 = 11;
int delayTime = 100;       // Delay que determina la velocidad de giro

void setup() {
pinMode(motorPin1, OUTPUT); // Configuración de los PINes como salida digital
pinMode(motorPin2, OUTPUT);
pinMode(motorPin3, OUTPUT);
pinMode(motorPin4, OUTPUT);
}

void loop() {
digitalWrite(motorPin1, HIGH);   // Los pines se activan en secuencia
digitalWrite(motorPin2, HIGH);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, LOW);

delay(delayTime);
 

digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
digitalWrite(motorPin3, HIGH);
digitalWrite(motorPin4, LOW);
 

delay(delayTime);
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, HIGH);
digitalWrite(motorPin4, HIGH);
 

delay(delayTime);
 

digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, HIGH);
 

delay(delayTime);
}

Este programa lo podriamos probar para las pruebas del funcionamiento del motor porque,en realidad, vamos a utilizar,como se dijo antes, una librería muy simple.

El video de muestra el funcionamiento del motor:

 

http://www.youtube.com/watch?v=-YcMSy3VpPQ