Proyectos

now browsing by category

En esta sección encontrarás proyectos e información para tu arduino, tanto de nuestra propia cosecha como los más interesantes que encontremos por internet y creamos que puedan ser útiles para todos ;)

 

Poppy Tu humaniode Open Source

Poppy tu robot humaniode open source !

 

nos encanta este proyecto y te dejamos los enlaces necesarios par que tengas a tu nuevo amigo Poppy en casa pronto .

Open Source Humanoid

 

Poppy GitHub Project

Poppy Web

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

TABBY Arduino + Open Source Vehicle (IKEA CAR)

Os presentamos un interesante proyecto Open Source para construir tu propio vehículo…

“Tabby es un framework de código abierto para los vehículos”
TABBY es el primer prototipo de código abierto. Se ha definido como el “Ikea Car” y el “Arduino para la movilidad”. Se trata de una plataforma versátil que se puede utilizar para crear su propio vehículo, con fines educativos, y mucho más.

CÓDIGO ABIERTO
Todos los detalles y planos para TABBY se pueden descargar en la sección de descargas de la página web.

Os invitamos y animamos a mejorar los diseños, trabajar en ellos, y subirlos para compartir sus ideas con la comunidad a través del foro OSV.

Open Source Car

TABBY

http://www.osvehicle.com/tabby-info/

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

TEMBO : Arduino Internet of things Api Conection

tembo

Arduino YUN + TEMBO = 2a Revolución Industrial ?

El Arduino Yun viene cargado con el poder de Temboo, por lo que es fácil de conectar con una amplia gama de recursos y servicios basados ​​en la Web.

Temboo es una interface de desarrollo, que provee, una serie de apis, para conectar nuestro arduino YUN a casi cualquier cosa que os imaginéis.

Desde Proyectosarduino.com os recomendamos que no perdáis de vista esta solución, ya que creemos que este es el punto que faltaba para que Internet of Things Arranque de verdad!

Temboo, integrado con el poder de otros frameworks para hardware como “COSA” puede generar proyectos muy interesantes, que os iremos contando y explicando ;D

Os dejamos los enlaces de interés de la plataforma TEMBOO

Web Oficial

Blog Temboo

Las principales Api que pueden integrarse con Arduino Yun mediante Temboo son :

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Cosa – Programación orientada a objetos para Arduino

2013-04-28 16.39.10

COSA : Comunicación de protocolos en Arduino

by: Mikael Patel

Cosa es una plataforma orientada a objetos para Arduino que apoya un paradigma de programación orientado a eventos con máquinas de estados finitos simples. Contiene un amplio conjunto de clases para apoyar la rápida creación de prototipos de dispositivos de Internet – de – cosas . Cosa es compatible con los siguientes módulos AVR / ATmega / ATtiny hardware interno ; todos los modos de actuador , Pins digitales y analógicos, variables de salidas y entradas , comparador analógico , PWM , Watchdog , Timer0 (RTC ) , Timer1 ( Servo ) , UART , USI , SPI, TWI y EEPROM.

Varias plataformas muy potentes están uniendo a arduino ” nuestro pequeño cerebrito digital ” a los objetos que nos rodean, si TEMBOO ha marcado un hito, en la conexión de la placa Arduino con casi todas las APIs Software que necesitamos para convertir nuestro mundo en digital, ahora mezclado con Cosa, tiene una proyección brutal.

Estamos seguros de que esté tipo de soluciones van a desembocar en una pequeña revolución, tanto industrial, como en la forma de entender los servicios y la vida en general.

Os dejamos los enlaces al Blog, al repositorio, y a la wiki del autor de COSA,

contienen proyectos interesantes, que seguro os van a gustar!..

Blog “Cosa”

Wiki

Github

Pronto colgaremos los más relevantes explicados paso a paso como solemos hacer en www.proyectosarduino.com

Un saludo!

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Interaction Factory ( Empresa de productos interactivos y multitouch )

anuncio_fb5

INTERACTION FACTORY.ES

Mucho ojo a estos chicos, que están revolucionando la manera de entender el Digital Signage,

La unión del mundo online y offline, esta cada vez más cerca…

Pantallas multitouch, desarrollos con Kinect, projectos de Arduino, processing, video mapping..

Muchos directores de Marketing, los tendrán en el punto de mira.

No os olvideis de darle al Me Gusta, en Facebook, y visitar su nueva página :

http://www.facebook.com/interactionfactory.es

http://www.interactionfactory.es

Suerte con este gran proyecto de Laboratorio Creativo !

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Hackea un peluche con Arduino !

Aquí os dejamos un interesante enlace para hackear un peluche y accionarlo mediante un tweet por ejemplo  ;P

 

tweet arduino  el archivo para descargar.

By Rob Millington and Stuart Dearnaley

 

 

 

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Clon Ambilight / Boblight con Arduino para XBMC

En esta ocasión aprovechamos para presentaros un proyecto sencillo, económico y muy resultón, que hará que vuestro salón destaque con luz propia.

Para este montaje hemos reutilizado pixel leds que nos han sobrado de un mega-proyecto que os presentaremos en breves, pero si donde hay un led hay alegría, nuestra oficina tiene que ser más empalagosa que disneyland  en la casa de la pradera ;)

Para meternos un poco en el tema, ¿Que nos cuenta wikipedia sobre el ambilight?

Ambilight es un sistema de retroiluminación impuesto por Philips para la línea de sus televisores planos de plasma y LCD. El Ambilight sirve para regular el contraste dentro de la habitación.

Ambilight es el resultado de un profundo estudio llevado a cabo sobre el modo en que las personas ven la televisión en casa. Entre los consumidores que probaron Ambilight, más del 70% opinaron que la iluminación alrededor del televisor contribuía a que la experiencia resultase más relajante y a que se mejorasen parámetros de la imagen tales como contraste, profundidad y viveza de los colores. Y el uso del color para la función Ambilight originaba una diferencia aun mayor. La SMTPE (Society of Television and Motion Picture Engineers) también recomienda las pantallas retroiluminadas para incrementar el rendimiento del televisor al máximo.

Ambilight es una tecnología diseñada para mejorar la experiencia visual y se puede utilizar con cualquier tipo de señal de televisión. Sea cual sea la fuente de la señal, la tecnología Ambilight analiza las señales entrantes y produce la luz lateral ambiental adecuada para el contenido que se está visualizando en la pantalla.

En nuestro caso, la conectaremos a una raspberry pi con raspbmc en su última versión, la cual facilita mucho el asunto al tener ya soporte oficial para boblight ;)

Se puede usar en XBMC corriendo en linux, osx y windows.

El montaje se puede hacer o bien con los puertos gpio de la propia raspberry, o delegando el control de los leds a un arduino, lo cual libera la cpu de carga, modo que hemos elegido en este caso.

Materiales necesarios para el montaje:

  1. Arduino uno, mega o equivalentes (se pueden usar leonardo y due, pero es desaprovecharlos y hay que sacar los pines del ICSP)
  2. 50 Leds direccionables con controlador WS2801
  3. Fuente de alimentación de mínimo 2A (para los 50 leds usados, hay que dimensionarla acorde a los leds utilizados)
  4. Cables con conector macho para breadboard (muy útiles y baratos)

Los leds direccionables pueden venir en 3 formatos principalmente, tiras (strip), encapsulado de goma tipo bullet, o encapsulado de goma plano. También los hay en unos pcb cuadrados, pero son más para iluminación en exteriores. En otro post hablaremos mas sobre su funcionamiento y como se direccionan. Recomendamos bullet o planos, ya que con las cintas habría que cambiar todo el archivo de config al llevar mas leds.

Y como unas imágenes valen más que 1000 palabras… bullet, planos y strip

bullet_ws2801 plano_ws2801 strip_ws2801

Lo primero, cargamos el sketch en el

#include <SPI.h>

// LED pin for Arduino:
#define LED_DDR  DDRB
#define LED_PORT PORTB
#define LED_PIN  _BV(PORTB5)

static const uint8_t magic[] = {'A','d','a'};
#define MAGICSIZE  sizeof(magic)
#define HEADERSIZE (MAGICSIZE + 3)

#define MODE_HEADER 0
#define MODE_HOLD   1
#define MODE_DATA   2

static const unsigned long serialTimeout = 15000; // 15 seconds

void setup()
{
  uint8_t
    buffer[256],
    indexIn       = 0,
    indexOut      = 0,
    mode          = MODE_HEADER,
    hi, lo, chk, i, spiFlag;
  int16_t
    bytesBuffered = 0,
    hold          = 0,
    c;
  int32_t
    bytesRemaining;
  unsigned long
    startTime,
    lastByteTime,
    lastAckTime,
    t;

  LED_DDR  |=  LED_PIN; // Enable output for LED
  LED_PORT &= ~LED_PIN; // LED off

  Serial.begin(115200); // Teensy/32u4 disregards baud rate; is OK!

  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE0);
  SPI.setClockDivider(SPI_CLOCK_DIV16); // 1 MHz max, else flicker

  uint8_t testcolor[] = { 0, 0, 0, 255, 0, 0 };
  for(char n=3; n>=0; n--) {
    for(c=0; c<25000; c++) {
      for(i=0; i<3; i++) {
        for(SPDR = testcolor[n + i]; !(SPSR & _BV(SPIF)); );
      }
    }
    delay(1); // One millisecond pause = latch
  }

  Serial.print("Ada\n"); // Send ACK string to host

  startTime    = micros();
  lastByteTime = lastAckTime = millis();

  // loop() is avoided as even that small bit of function overhead
  // has a measurable impact on this code's overall throughput.

  for(;;) {

    // Implementation is a simple finite-state machine.
    // Regardless of mode, check for serial input each time:
    t = millis();
    if((bytesBuffered < 256) && ((c = Serial.read()) >= 0)) {
      buffer[indexIn++] = c;
      bytesBuffered++;
      lastByteTime = lastAckTime = t; // Reset timeout counters
    } else {
      // No data received.  If this persists, send an ACK packet
      // to host once every second to alert it to our presence.
      if((t - lastAckTime) > 1000) {
        Serial.print("Ada\n"); // Send ACK string to host
        lastAckTime = t; // Reset counter
      }
      // If no data received for an extended time, turn off all LEDs.
      if((t - lastByteTime) > serialTimeout) {
        for(c=0; c<32767; c++) {
          for(SPDR=0; !(SPSR & _BV(SPIF)); );
        }
        delay(1); // One millisecond pause = latch
        lastByteTime = t; // Reset counter
      }
    }

    switch(mode) {

     case MODE_HEADER:

      // In header-seeking mode.  Is there enough data to check?
      if(bytesBuffered >= HEADERSIZE) {
        // Indeed.  Check for a 'magic word' match.
        for(i=0; (i<MAGICSIZE) && (buffer[indexOut++] == magic[i++]););
        if(i == MAGICSIZE) {
          // Magic word matches.  Now how about the checksum?
          hi  = buffer[indexOut++];
          lo  = buffer[indexOut++];
          chk = buffer[indexOut++];
          if(chk == (hi ^ lo ^ 0x55)) {
            // Checksum looks valid.  Get 16-bit LED count, add 1
            // (# LEDs is always > 0) and multiply by 3 for R,G,B.
            bytesRemaining = 3L * (256L * (long)hi + (long)lo + 1L);
            bytesBuffered -= 3;
            spiFlag        = 0;         // No data out yet
            mode           = MODE_HOLD; // Proceed to latch wait mode
          } else {
            // Checksum didn't match; search resumes after magic word.
            indexOut  -= 3; // Rewind
          }
        } // else no header match.  Resume at first mismatched byte.
        bytesBuffered -= i;
      }
      break;

     case MODE_HOLD:

      // Ostensibly "waiting for the latch from the prior frame
      // to complete" mode, but may also revert to this mode when
      // underrun prevention necessitates a delay.

      if((micros() - startTime) < hold) break; // Still holding; keep buffering

      // Latch/delay complete.  Advance to data-issuing mode...
      LED_PORT &= ~LED_PIN;  // LED off
      mode      = MODE_DATA; // ...and fall through (no break):

     case MODE_DATA:

      while(spiFlag && !(SPSR & _BV(SPIF))); // Wait for prior byte
      if(bytesRemaining > 0) {
        if(bytesBuffered > 0) {
          SPDR = buffer[indexOut++];   // Issue next byte
          bytesBuffered--;
          bytesRemaining--;
          spiFlag = 1;
        }
        // If serial buffer is threatening to underrun, start
        // introducing progressively longer pauses to allow more
        // data to arrive (up to a point).
        if((bytesBuffered < 32) && (bytesRemaining > bytesBuffered)) {
          startTime = micros();
          hold      = 100 + (32 - bytesBuffered) * 10;
          mode      = MODE_HOLD;
	}
      } else {
        // End of data -- issue latch:
        startTime  = micros();
        hold       = 1000;        // Latch duration = 1000 uS
        LED_PORT  |= LED_PIN;     // LED on
        mode       = MODE_HEADER; // Begin next header search
      }
    } // end switch
  } // end for(;;)
}

void loop()
{
  // Not used.  See note in setup() function.
}

Una vez cargado el firm al arduino y conectados los leds,  al darle alimentación deberían de encenderse los leds en rojo, verde y azul. Si es así, ya lo tenemos listo!

Las tiras de leds tienen 4 cables (no tomar como referencia los colores, ya que en cada envío el chino los mandan distintos, tanto en posición como en color dependiendo de la remesa), 2 de alimentación, uno de señal y otro de reloj. En las cintas vienen perfectamente visibles. en los encapsulados, viene grabado en el pcb.

El cable de clock se conecta al clock del bus SPI, pin 13 en el arduino uno
El cable data se conecta al MOSI del SPI (master – to – slave data), pin 11 en el arduino
uno.

wiring-ambilight

Solo nos quedaría colocar los leds. Aqui cada uno se las ingenia como puede, canaletas, chapilla de madera, rejillas etc…

Nosotros hemos optado por tacos brida de pegar, con unas bridas agarrando los leds. Se nos acabaron durante el montaje, de ahí que no haya foto completa montado ;)

Viendo la tv por la parte trasera, hay que empezar por la parte inferior, e irlos colocando en dirección contraria a las agujas del reloj. Unas fotos para aclarar el montaje:

pruebas medio colocados

colocandodetalle colocando

Con esto, ya tendríamos la parte hardware finalizada, sencillo, no? ;)

Ahora vamos a conectarlo al raspbmc en su última versión (a partir de junio-julio). La instalación de raspbmc vamos a dejarla de lado ya que hay cientos de tutoriales en internet. Si hay alguna duda, podéis dejarla en los comentarios de la entrada.

Necesitamos saber la ip de nuestra raspi en la lan, la podemos ver en información del sistema.

Nos conectaremos por SSH con putty o algún otro cliente (user:pi / pass: raspberry)
Como esta última versión ya trae soporte para boblight, solo tenemos que añadir nuestro archivo de config.

En breves subiré el mío, pero mientras os dejo el que he usado inicialmente.

SSH:
sudo wget https://www.dropbox.com/s/f6u82rv22tofbgl/boblight_gpio.conf -O /etc/boblight.conf –no-check-certificate

Y a partir de ahí, solo os queda jugar con los valores del archivo de config para adaptarlo a vuestras necesidades, pero ya funcionaría correctamente.

sudo nano /etc/init/boblight-dispmanx.conf

Para activarlo, en la configuración de raspbmc, activar boblight (esta en el apartado de activar ssh, web, etc…)

Y así queda tras el primer arranque!

primera prueba

Cualquier duda, podeis dejarla en los comentarios.

Salu2!

Fuentes:

http://www.grabthiscode.com/diy/como-montar-tu-sistema-ambilight-en-casa-y-no-morir-en-el-intento/

http://www.briefer.es/2013/04/ambilight-con-arduino-adalight-ws2801-xbmc-y-boblight

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Android + Raspberry Pi

Android en la Raspberry Pi

Raspberry Pi es una pequeña computadora de un tamaño minúsculo y consumo energético aún menor,

que encierra un microprocesador ARM a 700 Mh, 512 Mb de ram y una GPU VideoCore IV.

Algo muy parecido a la arquitectura de nuestros smartphones favoritos.

Hay un proyecto que intenta portar Android a la genial Raspberry Pi, llamado Android Pi. En su web oficial nos proponen varias versiones de Android a instalar, todas en un estado un poco precario y no muy funcional de momento, lástima.

Las imágenes propuestas son:

Éstas imágenes se instalan en la tarjeta SD con el comando DD, de la forma habitual usada para instalar imágenes en la Raspberry Pi. Si sois nuevos podéis leer aquí las instrucciones para instalar las imágenes Android que nos proponen.

Espero que os guste !

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

BarCode escaner con Arduino y webcam

Lector de Código de barras con webcam y salida a display LCD JHD162A, mediante RoboRealm

project by : Daphne00Z

F6WA40FGPLJ2GQK.LARGE

Read the rest of this page »

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter

Arduino Domo

Arduino DOMO

presentamos un proyecto domotico totalmente funcional.

Proyecto by : ExControl

Se maneja desde una aplicación android y al configuración del mismo es realmente sencillo. Tan solo necesitas de un Arduino Mega y un Arduino Ethernet shield, (para trabajor con horarios ademas en necesario Real Time Clock Module RTC DS1307 ) para poder comenzar a configurar el sistema .

Con un solo arduino mega podemos controlar:

  • 6 zonas de iluminación con control de potencia.
  • 6 zonas Control on off.
  • 7 zonas Control de persianas o toldos
  • 3 Control de climatización con temperaturas de consigna.
  • 3 Control de Calefacción con temperaturas de consignas.
  • 2 zonas Control de riego automático.
  • Programación de horarios.
  • Programación de escenas o ambientes.
  • Control por voz.
  • Posibilidad de control desde fuera de la red local sin ip fija.
Instalaciones Domoticas con Arduino

Puedes adaptarla a cada aplicación en concreto modificando el programa base para arduino y configurando la aplicación android.

En la sección descargas dispones a enlaces a los diferentes programas, aplicación android para manejo y código para shield arduino.

Configuración Incial del Sistema

Como es natural lo primeros que necesitamos para poder trabajar con el sistema es el hardware necesario, los requisitos minimos son:

Para poder utiliara los horaros ademas sera necesario un modulo ds1307 rtc, Si ya dispones del hardware necesario lo siguiente es configurar el sistema.


Configuración Librerias.

No es necesario la descarga de ninguna librería adicional, no obstante si que es precisa una modificación en la librería EthernetUdp.

Esta modificación es necesaria ya que librería EthernetUdp tiene por defecto un tamaño máximo de 24 bytes para los paquetes.

Para que el sistema funcione completamente es necesario aumentar ese valor hasta 340, veamos como hacemos esto:

Abrir el archivo EthernetUdp.h, para encontrar este archivo entramos dentro de la carpeta del programa ARDUINO, una vez dentro de esta carpeta la ruta seria:

Libraries\Ethernet\EthernetUdp.h.

Una vez abierto el archivo buscamos la linea donde pone :

#define UDP_TX_PACKET_MAX_SIZE 24

y la modificamos por:

#define UDP_TX_PACKET_MAX_SIZE 340

Guardamos los camios realizados y listo.


Configurando el programa arduino.

Lo único que debemos configurar para comenzar a utilizar el sistema domótico es la parte correspondiente a nuestra red local, para esto buscamos lo siguiente en el programa, Si todavía no lo ha descargado pulsa aqui.

// NETWORK CONFIGURATION // IP Address, ADJUST TO YOUR LOCAL NETWORK
//If you change the IP address will have to adjust in android application
//If you change the Local Port address will have to adjust in android application
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 1, 200);
unsigned int localPort = 5000; // puerto local para eschucha de paquete

Como podemos ver esta parte corresponde a la configuración Ip de la tarjeta arduino, la dirección mac, y el puerto para la recepción de paquetes.
Téngase en cuenta que en la mayoría de los casos esta configuración funcionara sin ningún tipo de problema.
Para empezar a funcionar lo mejor es modificar solamente la direccion IP por una que este dentro de nuestro rango (Si fuera necesario)


Instala la Aplicación de Control Domotico Android

Esta es la aplicación para gestionar el sistema domotico, puede ser instalada en cualquier dispositivo android, y puede ser descargada a través del playstore, pulsa para descargar.

Instalaciones Domoticas con Arduino

Instalamos la aplicación desde el PlayStore y la ejecutamos. Cuando ejecutemos el sistema por primera vez este nos preguntar por la IP y el puerto de comunicaciones configuradas en la tarjeta arduino, si esta no fue modificada en el paso anterior simplemente aceptamos la que viene por defecto.

Eliminar y añadir Circuitos

Cuando instalamos la aplicación de control para android este presenta una configuración de zonas de control a modo de demostración, pero como es natural es totalmente personalizable a nuestra instalación.

El sistema por defecto trae configuradas todas las zonas de control. Para adaptar esta configuración entramos en el menú administrador, para llegar a este desde la pantalla principal pulsamos sobre la el botón Configuración.

Instalaciones Domoticas con Arduino

Cuando pulsemos este entraremos en el menú de configuración del sistema, nos vamos a la parte de abajo del mismo y pulsamos sobre Menú Administrador, es posible que nos solicite una contraseña, aceptamos la que nos ofrece por defecto.

Menu administrador Domoticas con Arduino

Llegados a este punto nos aparece una pantalla con diferentes opciones, buscamos la ultima en la que nos indica configuración de circuitos, hacemos una pulsación larga sobre este para activar.

Una vez realizado esto nos encontramos con una pantalla en la cual vienen representados todos los circuitos y zonas de control, para eliminar un circuito hacemos una pulsación sobre el circuito en cuestión, con esto el presenta el sistema un lista de opciones, buscamos la ultima que pone borrar circuito, con esto ya no aparecerá en ninguna de las opciones del sistema (horarios, escenas….)

Una vez borrado el circuito vemos en la lista como sus campo nombre y descripción están vacíos, pues bien para que vuelva a aparecer el circuito en el sistema solo tenemos que definir un nombre al circuito, esto se puede hacer en este mismo menú, pulsando sobre la zona de control y seleccionando cambiar Nombre.

Cuando este todo configurado a nuestro gusto pulsamos sobre el botón guardar situado en la parte de abajo del sistema para que los cambios queden reflejados.

Modificar nombres de circuitos y zonas.

Cuando instalamos la aplicación de control para android este presenta una configuración de zonas de control a modo de demostración, pero como es natural es totalmente personalizable a nuestra instalación.

El sistema por defecto trae configuradas los nombres  de todas las zonas de control. Para adaptar esta configuración entramos en el menú administrador, para llegar a este desde la pantalla principal pulsamos sobre la el botón Configuración.

Instalaciones Domoticas con Arduino

Cuando pulsemos este entraremos en el menú de configuración del sistema, nos vamos a la parte de abajo del mismo y pulsamos sobre Menú Administrador, es posible que nos solicite una contraseña, aceptamos la que nos ofrece por defecto.

Menu administrador Domoticas con Arduino

Llegados a este punto nos aparece una pantalla con diferentes opciones, buscamos la ultima en la que nos indica configuración de circuitos, hacemos una pulsación larga sobre este para activar.

Una vez realizado esto nos encontramos con una pantalla en la cual vienen representados todos los circuitos y zonas de control, para modificar el nombre de un circuito hacemos una pulsación sobre el circuito en cuestión, con esto el presenta el sistema un lista de opciones, buscamos la primera en la  que pone cambiar nombre.

Con esto aparece un cuadro de dialogo donde podemos introducir un nuevo nombre para la zona de control, escribimos el nuevo valor para el campo nombre y pulsamos aceptar.

Cuando este todo configurado a nuestro gusto pulsamos sobre el botón guardar situado en la parte de abajo del sistema para que los cambios queden reflejados.

Modificar descripción de circuitos y zonas.

Cuando instalamos la aplicación de control para android este presenta una configuración de zonas de control a modo de demostración, pero como es natural es totalmente personalizable a nuestra instalación.

El sistema por defecto trae configuradas las descripciones  de las zonas de control. Para adaptar esta configuración entramos en el menú administrador, para llegar a este desde la pantalla principal pulsamos sobre la el botón Configuración.

Instalaciones Domoticas con Arduino

Cuando pulsemos este entraremos en el menú de configuración del sistema, nos vamos a la parte de abajo del mismo y pulsamos sobre Menú Administrador, es posible que nos solicite una contraseña, aceptamos la que nos ofrece por defecto.

Menu administrador Domoticas con Arduino

Llegados a este punto nos aparece una pantalla con diferentes opciones, buscamos la ultima en la que nos indica configuración de circuitos, hacemos una pulsación larga sobre este para activar.

Una vez realizado esto nos encontramos con una pantalla en la cual vienen representados todos los circuitos y zonas de control, para modificar la descripción de un circuito hacemos una pulsación sobre el circuito en cuestión, con esto el presenta el sistema un lista de opciones, buscamos la segunda en la que pone cambiar descripción.

Con esto aparece un cuadro de dialogo donde podemos introducir un nuevo valor para la descripción de la zona de control, escribimos el nuevo valor y pulsamos aceptar.

Cuando este todo configurado a nuestro gusto pulsamos sobre el botón guardar situado en la parte de abajo del sistema para que los cambios queden reflejados.

**

Importante : Las Librerías

librerias

No es necesario la descarga de ninguna librería adicional.
No obstante si que es precisa una modificación en la librería EthernetUdp.

Esta modificación es necesaria ya que librería EthernetUdp tiene por defecto un tamaño máximo de 24 bytes para los paquetes.
Para que el sistema funcione completamente es necesario aumentar ese valor hasta 340, veamos como hacemos esto:

Abrir el archivo EthernetUdp.h, para encontrar este archivo entramos dentro de la carpeta del programa ARDUINO.
Una vez dentro de esta carpeta la ruta seria:
Libraries\Ethernet\EthernetUdp.h.

Una vez abierto el archivo buscamos la linea donde pone : #define UDP_TX_PACKET_MAX_SIZE 24

y la modificamos por:
#define UDP_TX_PACKET_MAX_SIZE 340 Guardamos los camios realizados y listo.

Codigo Arduino:


#include // needed for Arduino versions later than 0018

<em id="__mceDel"> #include
#include // UDP library from: bjoern@cs.stanford.edu 12/30/2008
#include
#include
#include
#include
#define DS1307_I2C_ADDRESS 0x68 //Direccion Reloj
#define ONE_WIRE_BUS 3 //Pin one wire
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
//ZONA DE CONFIGURACIONES
//Define numero de entradas salidas
//Configuracion Red</em>

/******************************************************************************************************************************/

//SETTINGS ZONE
//Defines number of inputs and outputs
//Network configuration
//Set or Restet Daylight saving time o DST
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
//Activa o desactiva cambio hora automatico invierno verano
//Set or Restet Daylight saving time o DST
//El modo dts esta configurado para europa
//Dts mode is set to europe
//Para otros paises configure funcion CargaHora()
//For other countries configure function CargaHora()
const boolean Enable_DaylightSavingTime = true;

//Numero de Entradas
//Number of Inputs
const int Number_Input = 10;
//Numero de Salidas
//Number of Outputs
const int Number_Output = 16;
//Numero de Persianas
//Number of blind
const int NumeroPersianas = 2;

//CONFIGURACION DE RED
//Direccion IP ES MUY PROBABLE QUE TENGAS QUE AJUSTARLO A TU RED LOCAL
//Cambia la ip por una dentro de tu rango, tambien debes actualizarla en tu aplicacion android
//Tambien puedes cambiar el puerto, por defecto 5000

// NETWORK CONFIGURATION
// IP Address, ADJUST TO YOUR LOCAL NETWORK
//If you change the IP address will have to adjust in android application
//If you change the Local Port address will have to adjust in android application

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 1, 200);
unsigned int localPort = 5000; // puerto local para eschucha de paquete

/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
//FIN DE ZONAS DE CONFIGURACIONES
//END SETTINGS ZONE
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/

OneWire oneWire(ONE_WIRE_BUS); // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
DallasTemperature sensorTemp(&amp;oneWire);// Pass our oneWire reference to Dallas Temperature.
DeviceAddress insideThermometer; // arrays to hold device address

// buffers para recepcion y envio de datos
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];

// Instanacia Ethernet UDP Para enviar y recibir paqueteP
EthernetUDP Udp;
//Varibles Reloj
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year,minutoMemory,TipoDia;
boolean HoraRetrasa;
unsigned long LastMsg;

//Variables Gestion Entradas Salidas
int PinInput[Number_Input]; //Asocia el pin a la entrada correspondiente
unsigned long LastTimeInput[Number_Input]; //Ultima vez que la entrada estaba en reposo
byte InState[Number_Input]; //Estado Entrada
int PinOutput[Number_Output]; //Asocia el pin a la entrada correspondiente

//Registros Salidas Circuitos
byte ElectricalCircuitValue[30];
byte Temperatura1=31;
byte Temperatura2=32;
byte Temperatura3=33;

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//Configuracion Persianas
/////////////////////////////////////////////////////////////////////////////////////////////////////////
byte PosicionPersiana[NumeroPersianas]; //Controla la posicion de la persiana % Subida
unsigned long TiempoMovPersiana[NumeroPersianas]; //Tiempo de mov desde el ultimo refresco

//Memoria de tiempos y posicion respecto a tiempo
unsigned long TiempoPosPersianaUp[NumeroPersianas]; //Posicion persiana en subida
unsigned long TiempoPosPersianaDown[NumeroPersianas]; //Posicion persiana en Bajada
unsigned long TimUpPersiana[NumeroPersianas]; //Tiempo en MicrosSg subida persiana
unsigned long TimDowPersiana[NumeroPersianas]; //Tiempo en MicrosSg bajada persiana

//Variables para salidas y entradas
boolean OutUpPersiana[NumeroPersianas]; //Boleana para activar salida persiana
boolean OutDowPersiana[NumeroPersianas]; //Boleana para activar salida persiana
boolean InUpPersiana[NumeroPersianas]; //Boleana pulsador subida Persiana
boolean InDowPersiana[NumeroPersianas]; //Boleana pulsador bajada Persiana

void setup() {
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
//ZONA DE CONFIGURACIONES
//Configura pines de entrada
//Configura pines salida
/******************************************************************************************************************************/

//SETTINGS ZONE
//inputs PIN, number in arduino board
//Output Pin, number in arduino board
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/

//Pines de entrada
PinInput[0]=40;
PinInput[1]=41;
PinInput[2]=42;
PinInput[3]=43;
PinInput[4]=44;
PinInput[5]=45;
PinInput[6]=46;
PinInput[7]=47;
PinInput[8]=48;
PinInput[9]=49;

//Pines de salida

PinOutput[0]=22;
PinOutput[1]=23;
PinOutput[2]=24;
PinOutput[3]=25;
PinOutput[4]=26;
PinOutput[5]=27;
PinOutput[6]=28;
PinOutput[7]=29;
PinOutput[8]=30;
PinOutput[9]=31;
PinOutput[10]=32;
PinOutput[11]=33;
PinOutput[12]=34;
PinOutput[13]=35;
PinOutput[14]=36;
PinOutput[15]=37;
/***********************************************************************************************************************/
/***********************************************************************************************************************/
//FIN DE ZONAS DE CONFIGURACIONES
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/

//Serial.begin(9600);
// Inico Ethernet y UDP

Ethernet.begin(mac,ip);
Udp.begin(localPort);

//Inicio control Horarios
Wire.begin();
CargaHora();

//Iniciamos Entradas Salidas
for (int i =0; i&lt;30; i++){ElectricalCircuitValue[i]=0;}

//Fijamos pines entrada salida
unsigned long currenMillis = millis();
for (int i=0; i&lt;Number_Input;i++){pinMode(PinInput[i], INPUT);LastTimeInput[i]=currenMillis;InState[i]=0;}
for (int i=0; i&lt;Number_Output;i++){pinMode(PinOutput[i], OUTPUT);}

//Fijamos Temp. Consigna en Inicio
ElectricalCircuitValue[20]=20;
ElectricalCircuitValue[21]=20;
ElectricalCircuitValue[22]=20;

// Localizar sensores de temp. en bus
sensorTemp.begin();
// set the resolution to 9 bit (Each Dallas/Maxim device is capable of several different resolutions)
sensorTemp.getAddress(insideThermometer, 0);
sensorTemp.setResolution(insideThermometer, 9);

//Fijamo valores y posicion inicio persianas
//Fijamos el tiempo de subida bajada Persianas
//Se encuentran apartir de la direccion 3880
//
ReiniciarTiempoPersianas();

//Subimos las persianas a iniciar para ajustar posicion
for (int per=0; per&lt;NumeroPersianas; per++){
ReiniciarPosicionPersiana(per);
InDowPersiana[per]=false;
InUpPersiana[per]=false;
}

}
/***********************************************************************************************************************/
/***********************************************************************************************************************/
//EVENTOS CONTROL ENTRADAS SALIDAS
//INPUT OUTPUT CONTROL EVENTS

//DOS EVENTOS PARA ENTRADAS DIGITALES
//PULSACION CORTA
//PULSACION LARGA, MAYOR DE 0.5 SEGUNDOS

// THREE EVENTS FOR DIGITAL INPUTS
// PRESS SHORT
// PRESS LONG, OVER 0.5 SECONDS
// LONG PRESS END.

/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
void ShortInput(int NumberInput){
/*****************************************************************/
//Este evento se produce con una pulsación corta.
// This event occurs with a short press.
/*****************************************************************/
//Ejemplo de uso
// Example of use

//Iluminacion 1
if (NumberInput==0){
switch (ElectricalCircuitValue[0]) {
case 0:
ElectricalCircuitValue[0]=3; break;
case 1:
ElectricalCircuitValue[0]=3; break;
case 2:
ElectricalCircuitValue[0]=1; break;
case 3:
ElectricalCircuitValue[0]=2; break;
}
}
//Iluminacion 2
if (NumberInput==2){
switch (ElectricalCircuitValue[1]) {
case 0:
ElectricalCircuitValue[1]=3; break;
case 1:
ElectricalCircuitValue[1]=3; break;
case 2:
ElectricalCircuitValue[1]=1; break;
case 3:
ElectricalCircuitValue[1]=2; break;
}
}
//Enchufe 1
if (NumberInput==7){if (ElectricalCircuitValue[6]==1){ElectricalCircuitValue[6]=0;}else{ElectricalCircuitValue[6]=1;}}

//Enchfue 2
if (NumberInput==6){if (ElectricalCircuitValue[7]==1){ElectricalCircuitValue[7]=0;}else{ElectricalCircuitValue[7]=1;}}

//Persianas
//blind
//Ejemplo de uso
// Example of use
/*
//Persiana 1
if (NumberInput==1){ElectricalCircuitValue[23]=100;}
if (NumberInput==5){ElectricalCircuitValue[23]=0;}
//Persiana 2
if (NumberInput==9){ElectricalCircuitValue[24]=100;}
if (NumberInput==4){ElectricalCircuitValue[24]=0;}
*/
}
void LongInputEnd(int NumberInput){
/*****************************************************************/
//FINAL DE PULSACION LARGA
//LONG PRESS END, EVENT
// This event occurs with end a long press.
/*****************************************************************/

//Persianas
//blind
//Ejemplo de uso
// Example of use

/*
if (NumberInput==1){InUpPersiana[0]=false;}
if (NumberInput==5){InDowPersiana[0]=false;}
if (NumberInput==9){InUpPersiana[1]=false;}
if (NumberInput==4){InDowPersiana[1]=false;}
*/
}
void LongInput(int NumberInput){
/*****************************************************************/
//EVENTO PRODUCINO AL INICIO DE UNA PULSACION LARGA
// LONG PRESS START
// This event occurs with start a long press.
/*****************************************************************/
//Ejemplo de uso
// Example of use

//Pulsador Iluminacion 1
if (NumberInput==0){ElectricalCircuitValue[0]=0;}

//Pulsador Iluminacion 2
if (NumberInput==2){ElectricalCircuitValue[1]=0;}

//Pulsador Enchufe 1
if (NumberInput==7){ElectricalCircuitValue[6]=1;ElectricalCircuitValue[7]=1;ElectricalCircuitValue[8]=1;}

//Pulsador Enchfue 2
if (NumberInput==6){ElectricalCircuitValue[6]=0;ElectricalCircuitValue[7]=0;ElectricalCircuitValue[8]=0;}

//Persianas
//blind
//Ejemplo de uso
// Example of use
/*
if (NumberInput==1){InUpPersiana[0]=true;InDowPersiana[0]=false;}
if (NumberInput==5){InDowPersiana[0]=true;InUpPersiana[0]=false;}
if (NumberInput==9){InUpPersiana[1]=true;InDowPersiana[1]=false;}
if (NumberInput==4){InDowPersiana[1]=true;InUpPersiana[1]=false;}
*/
}
void OutControl()
{
/*************************************************************/
//Gestion Salidas
//Activamos los reles de control.

// Outputs Management
// Activate control relays.
/*************************************************************/
//Ejemplo de uso
// Example of use

// Circuito Numero 1
//Iluminacion Iluminacion con 3 puntos de luz controlados mediante 2 Reles.
switch (ElectricalCircuitValue[0]) {
case 0: // your hand is on the sensor
digitalWrite(PinOutput[1], LOW);
digitalWrite(PinOutput[3], LOW);
break;
case 1: // your hand is close to the sensor
digitalWrite(PinOutput[1], HIGH);
digitalWrite(PinOutput[3], LOW);
break;
case 2: // your hand is a few inches from the sensor
digitalWrite(PinOutput[1], LOW);
digitalWrite(PinOutput[3], HIGH);
break;
case 3:
digitalWrite(PinOutput[1], HIGH);
digitalWrite(PinOutput[3], HIGH);
break;
default:
ElectricalCircuitValue[0]=0;
break;
}

// Circuito Numero 2
//Iluminacion Iluminacion con 3 puntos de luz controlados mediante 2 Reles.
switch (ElectricalCircuitValue[1]) {
case 0:
digitalWrite(PinOutput[5], LOW);
digitalWrite(PinOutput[7], LOW);
break;
case 1:
digitalWrite(PinOutput[5], HIGH);
digitalWrite(PinOutput[7], LOW);
break;
case 2:
digitalWrite(PinOutput[5], LOW);
digitalWrite(PinOutput[7], HIGH);
break;
case 3:
digitalWrite(PinOutput[5], HIGH);
digitalWrite(PinOutput[7], HIGH);
break;
default:
ElectricalCircuitValue[1]=0;
break;
}
// Circuito Numero 7
//Enchufe
//Enchufes
switch (ElectricalCircuitValue[6]) {
case 0:
digitalWrite(PinOutput[15], HIGH);
break;
case 1:
digitalWrite(PinOutput[15], LOW);
break;
default:
ElectricalCircuitValue[6]=0;
}
// Circuito Numero 8
//Enchufe numero 1
switch (ElectricalCircuitValue[7]) {
case 0:
digitalWrite(PinOutput[13], HIGH);
break;
case 1:
digitalWrite(PinOutput[13], LOW);
break;
default:
ElectricalCircuitValue[7]=0;
}
// Circuito Numero 9
//Enchufe numero 1
switch (ElectricalCircuitValue[8]) {
case 0:
digitalWrite(PinOutput[11], HIGH);
break;
case 1:
digitalWrite(PinOutput[11], LOW);
break;
default:
ElectricalCircuitValue[8]=0;
}
// Circuito Numero 10
//Enchufe numero 1
if ((OutDowPersiana[0]==true)||(OutUpPersiana[0]==true))
{
if ((OutDowPersiana[0]==true)&amp;&amp;(OutUpPersiana[0]==false)){digitalWrite(PinOutput[2], LOW); digitalWrite(PinOutput[0], LOW); }
if ((OutDowPersiana[0]==false)&amp;&amp;(OutUpPersiana[0]==true)){digitalWrite(PinOutput[2], HIGH); digitalWrite(PinOutput[0], LOW); }
}
else{
digitalWrite(PinOutput[0], HIGH);
digitalWrite(PinOutput[2], HIGH);
}
//Persiana 2
if ((OutDowPersiana[1]==true)||(OutUpPersiana[1]==true))
{
if ((OutDowPersiana[1]==true)&amp;&amp;(OutUpPersiana[1]==false)){digitalWrite(PinOutput[6], LOW); digitalWrite(PinOutput[4], LOW); }
if ((OutDowPersiana[1]==false)&amp;&amp;(OutUpPersiana[1]==true)){digitalWrite(PinOutput[6], HIGH); digitalWrite(PinOutput[4], LOW); }
}
else{
digitalWrite(PinOutput[4], HIGH);
digitalWrite(PinOutput[6], HIGH);
}

//Reles de reserva
//Su estado de reposo corresponde a un nivel logico alto
digitalWrite(PinOutput[8], HIGH);
digitalWrite(PinOutput[10], HIGH);
digitalWrite(PinOutput[12], HIGH);
digitalWrite(PinOutput[14], HIGH);

}

/***********************************************************************************************************************/
/***********************************************************************************************************************/
//FIN DE ZONAS DE CONFIGURACIONES
//NO ES NECESARIO PROGRAMAR NADA POR DEBAJO DE ESTE PUNTO

/***********************************************************************************************************************/
// END CONFIGURATION ZONE
// NO NEED TO SET ANYTHING BELOW THIS POINT
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
/***********************************************************************************************************************/
void loop(){

if(millis() &lt; LastMsg ) {CargaHora();} if((millis() - LastMsg) &gt;= 30000) {CargaHora();}

RecepcionPaqueteUDP();
InputState();
for (int p =0; p&lt;NumeroPersianas;p++){GestionMovPersianas(p);} //Control de movimiento persianas
OutControl();
}
void InputState(){
for (int i=0; i&lt;Number_Input;i++){ unsigned long InputMillis = millis()-LastTimeInput[i]; if (InState[i]&gt;=4){InState[i]=0;}
if (digitalRead(PinInput[i]) == LOW ) {
if ((InState[i]==0)&amp;&amp;(InputMillis&gt;=60)){LastTimeInput[i]=millis();InState[i]=1;}
if ((InState[i]==1)&amp;&amp;(InputMillis&gt;=440)){LongInput(i);InState[i]=2;}
if (InState[i]==2){LastTimeInput[i]=millis();}
if (InState[i]==3){LastTimeInput[i]=millis();InState[i]=1;}
}
else{

if (InState[i]==0){LastTimeInput[i]=millis();}
if (InState[i]==1){LastTimeInput[i]=millis();InState[i]=3;}
if ((InState[i]==2) &amp;&amp;(InputMillis&gt;=60)){LastTimeInput[i]=millis();InState[i]=0;LongInputEnd(i);}
if ((InState[i]==3)&amp;&amp;(InputMillis&gt;=60)){LastTimeInput[i]=millis();InState[i]=0;ShortInput(i);}
}
}
}

/*************************************************************/
//Gestion Persianas
/*************************************************************/
void GestionMovPersianas(int NPersiana){
if (InUpPersiana[NPersiana] || InDowPersiana[NPersiana])
{ //Funcionamiento Manual
if (InUpPersiana[NPersiana] &amp;&amp; InDowPersiana[NPersiana]){OutDowPersiana[NPersiana]=false;OutUpPersiana[NPersiana]=false;}
else{
if (InUpPersiana[NPersiana]){SubirPersiana(NPersiana);}
if (InDowPersiana[NPersiana]){BajarPersiana(NPersiana);}
ElectricalCircuitValue[23 + NPersiana]=PosicionPersiana[NPersiana];
}
}
else
{ //Funcionamiento Automatico;
if (ElectricalCircuitValue[23 + NPersiana]==PosicionPersiana[NPersiana]){OutDowPersiana[NPersiana]=false;OutUpPersiana[NPersiana]=false;}
else
{
if (ElectricalCircuitValue[23 + NPersiana] &gt; PosicionPersiana[NPersiana]){SubirPersiana(NPersiana);}
else {if (ElectricalCircuitValue[23 + NPersiana] &lt; PosicionPersiana[NPersiana]) {BajarPersiana(NPersiana);}}
}
}
}
void SubirPersiana(int NPersiana){
if (OutDowPersiana[NPersiana]==true){BajarPersiana(NPersiana);OutDowPersiana[NPersiana]=false;OutControl();delay(200);}
long TiempoActual = micros();
if (OutUpPersiana[NPersiana]==false){OutUpPersiana[NPersiana]=true;}
else{
long DiferenciaTiempo;
if (TiempoActual&lt;TiempoMovPersiana[NPersiana]){DiferenciaTiempo=TiempoActual;}else{DiferenciaTiempo = TiempoActual-TiempoMovPersiana[NPersiana];}
if ((TiempoPosPersianaUp[NPersiana] + DiferenciaTiempo)&lt;TimUpPersiana[NPersiana]){TiempoPosPersianaUp[NPersiana]=TiempoPosPersianaUp[NPersiana] + DiferenciaTiempo;}
else{TiempoPosPersianaUp[NPersiana]=TimUpPersiana[NPersiana];}
byte porcentajeSubida = TiempoPosPersianaUp[NPersiana] / (TimUpPersiana[NPersiana]/100);
byte porcentajeBajada=100-porcentajeSubida;
PosicionPersiana[NPersiana]=porcentajeSubida;
TiempoPosPersianaDown[NPersiana]=porcentajeBajada*(TimDowPersiana[NPersiana]/100);
}
TiempoMovPersiana[NPersiana]=TiempoActual;
}
void BajarPersiana(int NPersiana){
if (OutUpPersiana[NPersiana]==true){SubirPersiana(NPersiana);OutUpPersiana[NPersiana]=false;OutControl();delay(200);}
long TiempoActual = micros();
if (OutDowPersiana[NPersiana]==false){OutDowPersiana[NPersiana]=true;}
else{
long DiferenciaTiempo;
if (TiempoActual&lt;TiempoMovPersiana[NPersiana]){DiferenciaTiempo=TiempoActual;}else{DiferenciaTiempo = TiempoActual-TiempoMovPersiana[NPersiana];}
if ((TiempoPosPersianaDown[NPersiana] + DiferenciaTiempo)&lt;TimDowPersiana[NPersiana]){TiempoPosPersianaDown[NPersiana]=TiempoPosPersianaDown[NPersiana] + DiferenciaTiempo;}else{TiempoPosPersianaDown[NPersiana]=TimDowPersiana[NPersiana];}

byte porcentajeBajada = TiempoPosPersianaDown[NPersiana] / (TimDowPersiana[NPersiana]/100);
byte porcentajeSubida=100-porcentajeBajada;
PosicionPersiana[NPersiana]=porcentajeSubida;
TiempoPosPersianaUp[NPersiana]=porcentajeSubida*(TimUpPersiana[NPersiana]/100);
}
TiempoMovPersiana[NPersiana]=TiempoActual;
}
void ReiniciarTiempoPersianas(){for ( int c =0; c&lt;NumeroPersianas; c++){TimUpPersiana

1

=(EEPROM.read(3880 + c))* 1000000; TimDowPersiana

1

=(EEPROM.read(3890 + c))* 1000000;}}
void ReiniciarPosicionPersiana(int NumPersiana){ TiempoPosPersianaUp[NumPersiana]=0;TiempoPosPersianaDown[NumPersiana]=TimDowPersiana[NumPersiana];ElectricalCircuitValue[23+NumPersiana]=100;}

/*************************************************************/
//Gestion Comunicaciones
/*************************************************************/
void RecepcionPaqueteUDP()
{

// SI TENEMOS PAQUETES LEEMOS CONTENIDO
int packetSize = Udp.parsePacket();

if(packetSize)
{
//Leemos el paquete en packetBufffer

Udp.read(packetBuffer,UDP_TX_PACKET_MAX_SIZE);

//Cargamos el String con los datos de entrada
char CadenaEntrada[packetSize + 1];
for (int c=0;c&lt;packetSize;c++){CadenaEntrada

1

=packetBuffer

1

;}
CadenaEntrada[packetSize]='\0';
//Comprobamos la cadena de entrada gestionamos las salidas y enviamos la respuesta
String CadenaIn = (String)CadenaEntrada;

/***********************************************************************************/
//Gestion Trmas Entradas
/**********************************************************************************/

if (CadenaIn=="CLEARHORARIO"){for (int i = 1000; i &lt;= 3879; i++){EEPROM.write(i, 66);}EnviarRespuesta("HORARIOS BORRADOS"); return;}//Borra Horarios
if (CadenaIn=="CLEARESPCDAY"){for (int i = 3900; i &lt;= 3999; i++){EEPROM.write(i, 0);}EnviarRespuesta("DIAS ESPECIALES BORRADOS");return; }//Borra Dias Especiales if (CadenaIn.indexOf("SETFH")&gt;-1){
//Actuliza Fecha Y hora setDateDs1307(byte second, byte minute, byte hour, byte dayOfWeek, byte dayOfMonth, byte month, byte year)
setDateDs1307(packetBuffer[5] ,packetBuffer[6], packetBuffer[7], packetBuffer[8], packetBuffer[9], packetBuffer[10], packetBuffer[11]);
CargaHora();
ReadDate();
return;
}
if (CadenaIn.indexOf("READDAY")&gt;-1){//Lectura Dia Especial
char Respuesta[325];
Respuesta[0]='C';
Respuesta[1]='F';
Respuesta[2]='D';
Respuesta[3]='A';

int PunteroRegistro;
if (packetBuffer[7]=='2'){PunteroRegistro=3950;}else{PunteroRegistro=3900;}
for (int i = 0; i&lt;50;i++){Respuesta[i+4]=EEPROM.read(PunteroRegistro + i); } Respuesta[324]='\0'; EnviarRespuesta(Respuesta); return; } if (CadenaIn.indexOf("WRIDAYE")&gt;-1){//Escritura Dia Especial
int Reg;
int Pos=8;
if (packetBuffer[7]==2){Reg=3950;}else{Reg=3900;}
for (int i = Reg; i&lt;(Reg+50);i++){EEPROM.write(i,packetBuffer[Pos]);Pos++;} EnviarRespuesta("GUARDADO COMPLETO"); return; } if (CadenaIn.indexOf("READHOR")&gt;-1){//Lectura Horario
char Respuesta[325];
Respuesta[0]='H';
Respuesta[1]='O';
Respuesta[2]='R';
Respuesta[3]='A';
int Reg;
int Pos=4;
Reg=packetBuffer[7]*320+1000;
for (int i = Reg; i&lt;(Reg+320);i++){Respuesta[Pos]=EEPROM.read(i)+1;Pos++;} Respuesta[324]='\0'; EnviarRespuesta(Respuesta); return; } if (CadenaIn.indexOf("WRITHOR")&gt;-1){//Escritura Horario
int Reg;
int Pos=8;
Reg=packetBuffer[7]*320+1000;
for (int i = Reg; i&lt;(Reg+320);i++){EEPROM.write(i,packetBuffer[Pos]);Pos++;} EnviarRespuesta("GUARDADO COMPLETO"); return; } if (CadenaIn.indexOf("SVAL")&gt;-1){ElectricalCircuitValue[packetBuffer[4]-1]=packetBuffer[5]-1;EnvioEstadoActual();return;} //Nuevo Valor registro salida

if (CadenaIn=="VACT"){EnvioEstadoActual();return;} //Lectura actual Salidas

if (CadenaIn.indexOf("SSCE")&gt;-1)//Seleccion Escena
{
int Dir;
Dir = (int)packetBuffer[4];
Dir = (Dir-1) * 30;

for (byte i =0 ; i&lt;30;i++){byte val =EEPROM.read(Dir+i); if (val&lt;250){ElectricalCircuitValue[i]=val;}} EnvioEstadoActual(); return; } if (CadenaIn.indexOf("WESC")&gt;-1)//Escritura escena
{
int Dir;
Dir = (int)packetBuffer[4];
Dir = (Dir-1) * 30;
for (byte i = 0; i&lt;30;i++){EEPROM.write(i+Dir, packetBuffer[5+i]-1);} EnviarRespuesta("GUARDADO COMPLETO"); return; } if (CadenaIn == "ESTADOINST"){ReadDate();return;}//Lectura Estado Instalacion Fecha y Hora if (CadenaIn.indexOf("RESC")&gt;-1)//Lectura Escena
{
int Dir;
Dir = (int)packetBuffer[4];
Dir = (Dir-1) * 30;

char Respuesta[36];
Respuesta[0]='V';
Respuesta[1]='E';
Respuesta[2]='S';
Respuesta[3]='C';
Respuesta[4]=packetBuffer[4]; //Numero de Escena

for (int i = 0; i &lt; 30;i++)
{
byte V=EEPROM.read(Dir+i);
if (V&lt;=254){V++;}
Respuesta[i + 5 ]=V;
}
Respuesta[35]='\0';
EnviarRespuesta(Respuesta);
return;
}

if (CadenaIn == "ENABLEHOR")//Lectura Horarios Abilitados
{
char Respuesta[36];
Respuesta[0]='E';
Respuesta[1]='N';
Respuesta[2]='H';
Respuesta[3]='O';
Respuesta[4]='R';

for (int i = 0; i &lt; 30;i++){Respuesta[i + 5 ]=EEPROM.read(970+i)+1;} Respuesta[35]='\0'; EnviarRespuesta(Respuesta); return; } if (CadenaIn.indexOf("WHOR")&gt;-1)//Escritura ABILITACION HORARIOS
{
for (byte i = 0; i&lt;30;i++){EEPROM.write(i+970, packetBuffer[4+i]-1);}
EnviarRespuesta("GUARDADO COMPLETO");
return;
}

if (CadenaIn == "TIMPERSIANA")//Lectura Tiempos Persianas
{
char Respuesta[26];
Respuesta[0]='L';
Respuesta[1]='E';
Respuesta[2]='C';
Respuesta[3]='P';
Respuesta[4]='E'; //Numero de Escena

for (int i = 0; i &lt; 20;i++){ Respuesta[i + 5 ]=EEPROM.read(3880+i)+1;} Respuesta[25]='\0'; EnviarRespuesta(Respuesta); return; } if (CadenaIn.indexOf("WPERS")&gt;-1)//Escritura Valores Persianas
{
for (byte i = 0; i&lt;20;i++){EEPROM.write(i+3880, packetBuffer[5+i]-1);} ReiniciarTiempoPersianas(); EnviarRespuesta("GUARDADO COMPLETO"); return; } //Reiniciar persiana posicion Inicio if (CadenaIn.indexOf("RESTPER")&gt;-1){
ReiniciarPosicionPersiana(packetBuffer[7]-1);
EnviarRespuesta("RESETEANDO PERSIANA");
return;
}
//Si llegasmos aki el menaje es erroneo
EnviarRespuesta("REPETIRMSG");
}
}
void ReadDate(){
char Respuesta[26];
Respuesta[0]='E';
Respuesta[1]='S';
Respuesta[2]='T';
Respuesta[3]='A';
Respuesta[4]='C';
Respuesta[5]='T';

Respuesta[6]=TipoDia + 1;
Respuesta[7]=hour + 1;
Respuesta[8]=minute + 1;
Respuesta[9]=dayOfMonth + 1;
Respuesta[10]=month + 1;
Respuesta[11]=year + 1;

Respuesta[12]='\0';

EnviarRespuesta(Respuesta);
}
void EnvioEstadoActual()//Envia el estado actual de la instalación
{
char Respuesta[38];
Respuesta[0]='E';
Respuesta[1]='V';
Respuesta[2]='A';
Respuesta[3]='L';

for (byte i = 4; i&lt;34;i++) { Respuesta[i]=ElectricalCircuitValue[i-4]+1; } //Temp. Consigna Respuesta[34]= Temperatura1 + 1; Respuesta[35]= Temperatura2 + 1; Respuesta[36]= Temperatura3 + 1; Respuesta[37]='\0'; EnviarRespuesta(Respuesta); } void EnviarRespuesta(char ReplyBuffer[]) { // send a reply, to the IP address and port that sent us the packet we received Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); Udp.write(ReplyBuffer); Udp.endPacket(); } /******************************************************************************************************************/ //Funciones control Horarios /******************************************************************************************************************/ void CargaHora() { getDateDs1307(&amp;second, &amp;minute, &amp;hour, &amp;dayOfWeek, &amp;dayOfMonth, &amp;month, &amp;year); LastMsg=millis(); if (minute != minutoMemory){ActualizaMinuto(); } } void ActualizaMinuto() { if(Enable_DaylightSavingTime==true) { //Adelanta la hora.Apartir del dia 25 de Marzo, busca el primer domingo //y cuando se han las 2 de la noche adelanta el reloj una hora if (month==3) { if (dayOfMonth &gt;= 26)
{
if (dayOfWeek = 7)
{
if (hour==2)
{
hour = 3;
setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
}
}

}
}
//Retrasa la hora.Apartir del dia 25 de Octubre, busca el primer domingo
//y cuando se han las 2 de la noche retrasa el reloj una hora
if (month==10)
{
if (dayOfMonth &gt;= 26)
{
if (dayOfWeek = 7)
{
if ((hour==2)&amp;&amp;(HoraRetrasa==false))
{
hour = 1;
HoraRetrasa=true;
setDateDs1307(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
}
}

}
}
}
if (hour==3){HoraRetrasa=false;}
minutoMemory=minute;

//Calculo Tipo Dia Especial o Semanal
TipoDia=dayOfWeek;
int Reg;

for (Reg=3900; Reg&lt;=3948;Reg=Reg+2){if (month == EEPROM.read(Reg)){if (dayOfMonth== EEPROM.read(Reg+1)){TipoDia=8;}}}//Verificacion Dia Especial 1
for (Reg=3950; Reg&lt;=3998;Reg=Reg+2){if (month == EEPROM.read(Reg)){if (dayOfMonth== EEPROM.read(Reg+1)){TipoDia=9;}}}//Verificacion Dia Especial 2
//Verificacion Horarios para este Estado
int R= ((TipoDia-1)*320)+1000;
for (Reg=R; Reg&lt;=(R+316);Reg=Reg+4) {if ((hour==EEPROM.read(Reg))&amp;&amp;(minute==EEPROM.read(Reg+1))){byte ci=EEPROM.read(Reg+2);if ((ci&lt;30) &amp;&amp; (EEPROM.read(ci+970)==1)){ElectricalCircuitValue[ci]=EEPROM.read(Reg+3);}}}

//Actualzamos Temp.
sensorTemp.requestTemperatures(); // Send the command to get temperatures
float tempC = sensorTemp.getTempC(insideThermometer);
Temperatura1=(byte)tempC;
}
/******************************************************************/
// FUNCIONES RELOJ
/*****************************************************************/

// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
return ( (val/10*16) + (val%10) );
}

// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
return ( (val/16*10) + (val%16) );
}

// Stops the DS1307, but it has the side effect of setting seconds to 0
// Probably only want to use this for testing
/*void stopDs1307()
{
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.send(0);
Wire.send(0x80);
Wire.endTransmission();
}*/

// 1) Sets the date and time on the ds1307
// 2) Starts the clock
// 3) Sets hour mode to 24 hour clock
// Assumes you're passing in valid numbers
void setDateDs1307(byte second, // 0-59
byte minute, // 0-59
byte hour, // 1-23
byte dayOfWeek, // 1-7
byte dayOfMonth, // 1-28/29/30/31
byte month, // 1-12
byte year) // 0-99
{
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.write(0);
Wire.write(decToBcd(second)); // 0 to bit 7 starts the clock
Wire.write(decToBcd(minute));
Wire.write(decToBcd(hour)); // If you want 12 hour am/pm you need to set
// bit 6 (also need to change readDateDs1307)
Wire.write(decToBcd(dayOfWeek));
Wire.write(decToBcd(dayOfMonth));
Wire.write(decToBcd(month));
Wire.write(decToBcd(year));
Wire.endTransmission();
}

// Gets the date and time from the ds1307
void getDateDs1307(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
// Reset the register pointer
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.write(0);
Wire.endTransmission();

Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

// A few of these need masks because certain bits are control bits
*second = bcdToDec(Wire.read() &amp; 0x7f);
*minute = bcdToDec(Wire.read());
*hour = bcdToDec(Wire.read() &amp; 0x3f); // Need to change this if 12 hour am/pm
*dayOfWeek = bcdToDec(Wire.read());
*dayOfMonth = bcdToDec(Wire.read());
*month = bcdToDec(Wire.read());
*year = bcdToDec(Wire.read());
}

Aplicación Android :

https://play.google.com/store/apps/details?id=arduino.domotics.home.excontrol.free

Demo APK :

Aquí

Esperamos que os guste !

Gracias a Roberto de excontrol.es por el aporte.

Share this:
Share this page via Email Share this page via Stumble Upon Share this page via Digg this Share this page via Facebook Share this page via Twitter