martes, 4 de diciembre de 2012

Uso del módulo Enc28J60 con arduino, 2a. parte, control de salidas digitales desde internet



Protocolos de comunicación: SPI
SPI es un protocolo serial síncrono que se utiliza para comunicar un microcontrolador con otro y con periféricos a distancias cortas. Para hacer una conexion SPI siempre habrá un dispositivo maestro (usualmente un microcontrolador) que controlará uno o varios periféricos (esclavos), se utilizan por lo generar 3 lineas de conexión  y una de selección que son:

* SO o MISO (Master In Slave Out). La linea que utiliza el esclavo para enviar datos al maestro
* SI o MOSI (Master
Out Slave In). Datos del maestro al esclavo.
* SCK (Serial
clock). Pulsos de reloj para sincronizar la comunicación
* CS o
Select. Se usa por el master para habilitar o deshabilitar un determinado periférico

Los
microcontroladores atmel incluyen las 4 lineas para usar protocolo SPI las cuales obviamente están presentes en los pines del arduino, para el arduino uno se deben usar: Pin digital 10 para CS, Pin digital 11 para SI, Pin digital 12 para SO y Pin digital 13 para SCK, en el caso del arduino mega se usaría los sig. pines: 50 (MISO), 51 (MOSI), 52 (SCK), and 53 (CS).

La
alimentación del módulo puede  es a 3.3 los cuales son suministrados por el arduino

Protocolos de comunicación: HTTP
Hypertext Transfer Protocol o HTTP (en español protocolo de transferencia de hipertexto) es el protocolo usado en cada transacción de la Web.
Es un protocolo orientado a transacciones y sigue el esquema petición-respuesta entre un cliente y un servidor.
Al cliente que efectúa la petición (un navegador web o un spider) se lo conoce como "user agent" (agente del usuario). Y a la información transmitida se la llama recurso y se la identifica mediante un localizador uniforme de recursos (URL). Los recursos pueden ser archivos, el resultado de la ejecución de un programa, una consulta a una base de datos, en este caso en particular la respuesta será la lectura de un sensor o el resultado de la ejecución de un proceso en Arduino, etc.
El módulo ENC28J60 y su librería desarrollada para el arduino lo convierten en un pequeño servidor WEB capaz de responder a interacciones del usuario desde cualquier navegador.

Librería ENC28J60
El módulo que usaremos está basado en un chip ENC28J60 de Microchip que interactúa con Arduino y le permite la comunicación de datos mediante un puerto Ethernet.
Se integra el controlador de la MAC address, un buffer de 8 KB de transmisión/recepción de de paquetes de doble puerto y una FIFO circular que se gestionan a nivel de hardware, además permite la programación de retransmisión de datos en caso de colisión.
La librería de funciones fue desarrollada por Jean-Claude Wippler del sitio http://jeelabs.org y liberada con licencia creative commons como software libre, a partir de ahí ha sido utilizada por diferentes fabricantes para soportar diferentes productos basados en el mismo controlador.


Antes de iniciar la operación de nuestro módulo debemos llevara acabo la configuración de los parámetros para comunicación en la red ethernet, datos como:
Dirección IP
Máscara de red
Puerta de enlace
Tamaño del buffer de datos.
También es factible operar con una dirección IP Dinámica, con lo que sólo será necesario llamara a la función DHCP para solicitarla al gateway de la red.

Las principales funciones incluidas en la librería son:
ether.begin : Crea un objeto para interactuar con el controlador
ether.packetReceive(); Devuelve la cantidad de paquetes pendientes de recibir que estan almacenados en el buffer.
ether.packetLoop(len); Da entrada todos los paquetes almacenados en el buffer, len es la cantidad de paquetes que se van a recibir;
ether.httpServerReply(homePage()); Responde al cliente que realizo la petición, homePage es una variable que apunta a un string o cadena de texto con formato HTML con una respuesta válida para el cliente.

El siguiente programa controla el encendido y apagado de un led mediante una pagina web que se accede desde la direccion ip del modulo enc-28j60 conectado al arduino, el diagrama de conexion del modulo con el arduino es el que ya vimos en la primera parte de este tutorial mas un led conectado en el pin digital 2 que sera el que controlemos via red:

// Arduino demo sketch for testing ethernet
// 2012-09-20 lmdiaz@tecnotinker.com

// This sketch is derived from RF12eth.pde:
// May 2010, Andras Tucsni, http://opensource.org/licenses/mit-license.php

#include <EtherCard.h>

#define DEBUG   0   // set to 1 to display free RAM on web page
#define SERIAL  0   // set to 1 to show incoming requests on serial port

// buffer for an outgoing data packet
static char outCount = -1;


// configuration, as stored in EEPROM
struct Config {
    byte band;
    byte group;
    byte collect;
    word refresh;
    byte valid; // keep this as last byte
} config;


#define NUM_MESSAGES  10    // Number of messages saved in history
#define MESSAGE_TRUNC 15    // Truncate message payload to reduce memory use

static BufferFiller bfill;  // used as cursor while filling the buffer

static byte history_rcvd[NUM_MESSAGES][MESSAGE_TRUNC+1]; //history record
static byte history_len[NUM_MESSAGES]; // # of RF12 messages+header in history
static byte next_msg;       // pointer to next rf12rcvd line
static word msgs_rcvd;      // total number of lines received modulo 10,000
byte ledstatus = 0;
byte Ethernet::buffer[1000];   // tcp/ip send and receive buffer

// ethernet interface mac address
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };
// ethernet interface ip address
static byte myip[] = { 192,168,1,188 };
// gateway ip address
static byte gwip[] = { 192,168,1,1 };

#if DEBUG
static int freeRam () {
  extern int __heap_start, *__brkval; 
  int v; 
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval); 
}
#endif

void setup(){
#if SERIAL
    Serial.begin(57600);
    Serial.println("\n[etherNode]");
#endif

    
    if (ether.begin(sizeof Ethernet::buffer, mymac) == 0) 
      Serial.println( "Failed to access Ethernet controller");
    ether.staticSetup(myip, gwip);
  
#if SERIAL
    ether.printIp("IP: ", ether.myip);
#endif
}

char okHeader[] PROGMEM = 
    "HTTP/1.0 200 OK\r\n"
    "Content-Type: text/html\r\n"
    "Pragma: no-cache\r\n"
;

static void homePage(BufferFiller& buf, byte led) {
    
    buf.emit_p(PSTR("$F\r\n"
        "<meta http-equiv='refresh' content='$D'/>"
        "<title>Controlar un led desde internet</title>" 
        "<body><p>Estatus del led: $D</br>"
        "<a href='a'>Apagar</a> </br>"
        "<a href='e'>Encender</a><br></p>"), okHeader, 1, led);

    // Cronometrar el tiempo de ejecucion del programa
    long t = millis() / 1000;
    word h = t / 3600;
    byte m = (t / 60) % 60;
    byte s = t % 60;
    buf.emit_p(PSTR(
        "Tiempo corriendo $D$D:$D$D:$D$D</body>"), h/10, h%10, m/10, m%10, s/10, s%10);
#if DEBUG
    buf.emit_p(PSTR(" ($D bytes free)"), freeRam());
#endif
}

void loop(){
    word len = ether.packetReceive();
    word pos = ether.packetLoop(len);
    // check if valid tcp data is received
    if (pos) {
        bfill = ether.tcpOffset();
        char* data = (char *) Ethernet::buffer + pos;
        
        
#if SERIAL
        Serial.println(data);
#endif


        // Pagina sin solicitud
        if (strncmp("GET / ", data, 6) == 0) {
            homePage(bfill, ledstatus);
        }
        else if (strncmp("GET /a", data, 6) == 0) {
            // Recibimos el parametro a (apagar)
            homePage(bfill, ledstatus);//configPage(data, bfill);
            if(ledstatus == HIGH) {
              digitalWrite(2, LOW);
              ledstatus = LOW;
            } 
        }
        else if (strncmp("GET /e", data, 6) == 0) {
            // Recibimos el parametro e (encender)
            homePage(bfill, ledstatus);
            if(ledstatus == LOW) {
              digitalWrite(2, HIGH);
              ledstatus = HIGH;
            } 
        }
        else 
            bfill.emit_p(PSTR(
                "HTTP/1.0 401 Invalido\r\n"
                "Content-Type: text/html\r\n"
                "\r\n"
                "<h1>401 Unauthorized</h1>"));  
                
        ether.httpServerReply(bfill.position()); // send web page data
    }
}

jueves, 5 de julio de 2012

Uso del módulo ethernet ENC28J60 con Arduino : Parte 1

Hola, en esta ocación quiero compartir un tutorial para utilizar un módulo ENC28J60 que proporciona conectividad ethernet a cualquier microcontrolador, en este caso lo usaremos mediante un Arduino o sea un Atmega328

En el mercado encontraremos diferentes presentaciones de este módulo, algunas vienen en formato de Shield, yo consegui una tarjeta mas pequeña pero que se cablea facilmente al Arduino

El módulo que se uso para este tutorial es el siguiente:

Tambíen existe la version "shield":

En las bibliotecas de Arduino ya encontramos una librería ethernet, el problema es que esta librería esta diseñada para operar con un módulo diferente, el WIZnet W5100, por lo que no es compatible, despues de probar varias opciones al fin encontre una que funcionó sin problemas y que se puede descargar desde la sig. liga:

* Actualización al 26/11/2016

La versión actualizada de la librería la encuentran en la siguiente liga:

https://github.com/jcw/ethercard/archive/master.zip


Bueno empezaremos cableando el módulo ethernet al Arduino, para esto usamos el siguiente diagrama:


Cabe mencionar que la comunicacion entre el módulo ethernet y el arduino se lleva acabo utilizando un protocolo que se llama SPI o Serial Peripheral Interface


SPI es un protocolo serial sincrono que se utiliza para comunicar un microcontrolador con otro y con periféricos a distancias cortas.

Para hacer una conexion SPI siempre habrá un dispositivo maestro (usualmente un microcontrolador) que controlará uno o varios periféricos (esclavos), se utilizan por lo generar 3 lineas de conexión  y una de selección que son:

* SO o MISO (Master In Slave Out). La linea que utiliza el esclavo para enviar datos al maestro
* SI o MOSI (Master Out Slave In). Datos del maestro al esclavo.
* SCK (Serial clock). Pulsos de reloj para sincronizar la comunicación
* CS o Select. Se usa por el master para habilitar o deshabilitar un determinado periférico

Los microcontroladores atmel incluyen las 4 lineas para usar protocolo SPI las cuales obviamente están presentes en los pines del arduino, para el arduino uno se deben usar: Pin digital 10 para CS, Pin digital 11 para SI, Pin digital 12 para SO y Pin digital 13 para SCK, en el caso del arduino mega se usaría los sig. pines: 50 (MISO), 51 (MOSI), 52 (SCK), and 53 (CS).

La alimentación del módulo puede ser a 3.3 o 5V, yo usé ambos para las pruebas y no encontré ninguna diferencia así que lo deje puesto a 3.3V.


Así queda nuestro módulo cableado:



Después de cablear el módulo lo que sigue es instalar la librería, como estoy usando la versión de Windows, las rutas serán en ese formato, primero busco el archivo que descargué, el mio quedó guardado con el mismo nombre EtherCard.zip


A continuación descomprimo el archivo y envío la carpeta descomprimida al directorio de Arduino/libraries (o la ruta donde esté instalado el ide de arduino)




Después de este paso abrimos el IDE de arduino y en el menu de Ejemplos ya deben aparecer los ejemplos de la libreria EtherCard



Seleccionamos el ejemplo pingsStaticIP


En las variables myip y gwip colocamos primero la ip que querramos asignar al arduino (en mi caso 192.168.1.188) y después la ip de nuestra puerta de enlace o gateway, en méxico para las redes de infinitum y una gran mayoría de las redes domésticas este valor es el que se muestra (192.168.1.254), una vez hecho este pequeño cambio descargamos el script al arduino y abrimos el monitor serial donde vemos el arranque del script:


Si analizamos el script vemos que hay una rutina que obtiene via dns la direccion ip del dominio www.google.com y se queda enviándole pings, en el monitor vemos los tiempos de respuesta del servidor de google (Esta parte solo funcionará si estamos conectados a internet).

Si nosotros abrimos una ventana de comandos y hacemos ping a la dirección ip del arduino debemos ver una respuesta como la de abajo, en la pantalla del monitor serial tambíen podemos ver las solicitudes de ping enviadas por la pc y recibidas por el arduino


Si lograron llevar acabo con éxito todos los pasos felicidades! oficialmente acaban de darle conectividad de red a su arduino.

En la segunda parte del tutorial aprenderemos como convertir nuestro arduino en un servidor web para poder monitorear y controlar las salidas y entradas de la placa, hasta la próxima!

Con información tomada de:




martes, 8 de mayo de 2012

Proceso de ensambre del kit carro robot 4WD

1. Las piezas que lo conforman, se distinguen las dos placas de acrílico con su pelicula de proteccion (cafe), las 4 ruedas, los 4 motores, tornillos, amarres, portapilas y desarmador (incluido)
2. Aqui vemos un acercamiento de los brackets para los motores y la tornilleria
3. Acercamiento de los 4 motorreductores en L

4. Las ruedas y el portapilas con sus soportes.

5. Las placas base superior e inferior

6. Otra vista con el instructivo anexo
7. Siguiendo el instructivo terminamos el armado en menos de media hora, unicamente se ponen 2 tornillos por cada motor y luego 4 separadores para unir las placas de arriba y abajo, las ruedas entran a presion

8. Una vez terminado tenemos una plataforma bastante sólida y lista para la aplicación que queramos dare, seguidor de líneas, vehículo móvil autónomo o de radio control, etc.


9. Al chasis es necesario agregar el sistema de control que puede ser cualquier microcontrolador, p.ej. arduino, pic, etc. ademas de un circuito para controlar la potencia de los motores, p.ej. un L293D doble puente H, por último necesitamos algun tipo de sensor como puede ser un ultrasónico SR-04, o algun circuito reflexivo infrarrojo para convertirlo en un seguidor de líneas.




jueves, 26 de abril de 2012

Creación de un seguidor de linea con Arduino

Creación de un seguidor de linea con Arduino

Material necesario:


  • Placa de trovicel o acrílico aprox de 20x30cm
  • Par de servos de rotación contínua
  • Ruedas de cualquier tamaño, estas se pueden comprar o tomar "prestadas" de un juguete
  • Placa arduino uno
  • Placa se sensores infrarrojos cny-70 o similar, en mi caso usaré una placa adquirida en yourduino.com BFD-1000, esta compuesta de 6 sensores tcrt5000, 5 en la parte de abajo y uno al frente, ademas un micro-switch y sus respectivos leds indicadores
  • Cables y tornillos de diferentes medidas



Vista de la placa BFD-1000

Par de servos con adaptación para fijar las ruedas tomadas de un carrito


Para fijar los servos a la base fabriqué un par de soportes con un liston de metal tomado de un gabinete de pc, de los que vienen en la tapa de las ranuras para tarjetas, es una lámina delgada y se puede trabajar muy fácilmente, nos ahorramos tener que comprar soportes caros o usar soluciones poco profesionales como sujetadores o pegamento.


Aqui vemos el carrito casi terminado, con los servos sujetos por los soportes y la placa de sensores al frente



Aqui haciendo algunas pruebas con una placa yourduino roboI, es compatible con un arduino duemilanove y trae entradas para los pines pwm con alimentación y tierra, en estas entradas podemos conectar directamente los servos



Próximamente diagramas detallados y código del arduino para hacer el seguimiento de linea negra y blanca.

jueves, 12 de abril de 2012

Cubo de leds 4x4







A continuación les muestro el proceso de creacion de un pequeño cubo de leds que sera controlado con un arduino uno, se usan todos los pines para controlar cada uno de los 16 leds de cada nivel asi como 4 pines de voltaje comun 1 para cada piso del cubo, el tiempo aproximado de contruccion es de 4 a 6 horas dependiendo de la disponibilidad de materiales.






Paso 1. Perforar en una tabla una matriz de 4x4 con 2cm de separación entre cada perforación.




2. Doblar el cátodo de cada led para unirlo con el led contiguo, hacer 4 hileras iguales con 4 leds



3. Unir las 4 hileras de leds para formar un "piso" del cubo, unir un extremo con las patillas del ultimo led a la hilera siguiente y el extremo contrario con un cable del mismo grosor.






4. Unir los diferentes niveles del cubo soldando los anodos de cada led con su contraparte del nivel superior, puedes utilizar caimanes para fijar los niveles antes de soldar, empezar primero con las cuatro leds de las esquinas.





5. Una vez soldados los 4 niveles recortar las puntas sobrantes.



 6. Para cablear usé una tablilla de circuito prefabricada y pre-perforada, de aproximadamente 20x25 cm
 7. Soldamos los 16 leds del primer piso del cubo, haciendo sobresalir la punta solo lo necesario para soldar.





8. Concentramos la primera hilera de leds en la parte frontal de la tablilla, en esta parte frontal soldaremos un pequeño conector de 4 pines para poder puentear facilmente a los pines del arduino


















9. Repetir el proceso para las demas hileras,

 
10. Usamos un cable plano hembra-hembra junto con hileras de pines macho en las entradas del arduino podemos lograr una conexion bastante decente






























Las conexiones las deje como sigue:

Hilera 1 - Led 1 - Pin 0
Hilera 1 - Led 2 - Pin 1
Hilera 1 - Led 3 - Pin 2
Hilera 1 - Led 4 - Pin 3

Hilera 2 - Led 5 - Pin 4
Hilera 2 - Led 6 - Pin 5
Hilera 2 - Led 7 - Pin 6
Hilera 2 - Led 8 - Pin 7

Hilera 3 - Led 9 - Pin 8
Hilera 3 - Led 10 - Pin 9
Hilera 3 - Led 11 - Pin 10
Hilera 3 - Led 12 - Pin 11

Hilera 4 - Led 13 - Pin 12
Hilera 4 - Led 14 - Pin 13
Hilera 4 - Led 15 - Pin A5
Hilera 4 - Led 16 - Pin A6

Catodo comun nivel 1 - Pin A0
Catodo comun nivel 2 - Pin A1
Catodo comun nivel 3 - Pin A2
Catodo comun nivel 4 - Pin A3