Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
Casa unifamiliar-2 sistemas
#11
(03-13-2018, 07:49 AM)eugeniobcn Wrote:  
(03-13-2018, 07:22 AM)anigwei Wrote:  
(03-13-2018, 06:04 AM)eugeniobcn Wrote:  hola buenas, soy nuevo en el foro  tambien estoy diseñando mi casa domotica desde 0 con arduino, mi proyecto es similar, pero uso telerruptores controlados desde pulsadores y desde arduino para evitar ese problema,  de echo, puedo apagar completamente la electronica  de arduino y la instalacion seguira funcionando al 100%

saludos

Hola Eugeniobcn

Entonces el arduino controla los telerruptores realmente? De manera que en casa tienes una única instalacion hacia el cuadro de telerruptores, y el arduino los ataca a ellos? Buena idea, parece cara (n telerruptores por n circuitos) pero a la larga te ahorrarás problemillas.

Saludos,

Exacto, hay que lanzar 1retorno de cada línea que quieres encender  y de cada pulsador hasta el cuadro dónde se encuentran los Telerruptores, luego mediante  2optocopladores Arduino sabe si una línea está en on o off igual que si el pulsador está en abierto o cerrado de esta manera si pulsamos un pulsador brevemente encendemos si está apagado o viceversa, además si pulsamos largo podemos controlar por ejemplo un driver dimable 1/10v

¿Cómo lo haces con Optoacopladores? Yo he pedido ACS712 para usar de retorno en cada linea de los telerruptores.
Reply
#12
(03-13-2018, 10:00 PM)Elo Wrote:  
(03-13-2018, 07:49 AM)eugeniobcn Wrote:  
(03-13-2018, 07:22 AM)anigwei Wrote:  
(03-13-2018, 06:04 AM)eugeniobcn Wrote:  hola buenas, soy nuevo en el foro  tambien estoy diseñando mi casa domotica desde 0 con arduino, mi proyecto es similar, pero uso telerruptores controlados desde pulsadores y desde arduino para evitar ese problema,  de echo, puedo apagar completamente la electronica  de arduino y la instalacion seguira funcionando al 100%

saludos

Hola Eugeniobcn

Entonces el arduino controla los telerruptores realmente? De manera que en casa tienes una única instalacion hacia el cuadro de telerruptores, y el arduino los ataca a ellos? Buena idea, parece cara (n telerruptores por n circuitos) pero a la larga te ahorrarás problemillas.

Saludos,

Exacto, hay que lanzar 1retorno de cada línea que quieres encender  y de cada pulsador hasta el cuadro dónde se encuentran los Telerruptores, luego mediante  2optocopladores Arduino sabe si una línea está en on o off igual que si el pulsador está en abierto o cerrado de esta manera si pulsamos un pulsador brevemente encendemos si está apagado o viceversa, además si pulsamos largo podemos controlar por ejemplo un driver dimable 1/10v

¿Cómo lo haces con Optoacopladores? Yo he pedido ACS712 para usar de retorno en cada linea de los telerruptores.

uso un diodo 4004 o similar , una resistencia de 220k en serie con el opto 4n33, asi consigo prender el led interno del optp a 230V de alterna
a la salida del opto te encontraras con una secuencia de 1 y 0 cada vez que pasa la alterna por -0 sera cero y cuando es mayor de 0 sera 1
esto lo rectifico sencillamente con un electrolitico de 100MF queda un poco lento en el encendido, quizas unas centesimas de segundos casi inapreciable, pero hay que evitar esa fluctuacion no deseada
Reply
#13
(03-13-2018, 10:11 PM)eugeniobcn Wrote:  
(03-13-2018, 10:00 PM)Elo Wrote:  
(03-13-2018, 07:49 AM)eugeniobcn Wrote:  
(03-13-2018, 07:22 AM)anigwei Wrote:  
(03-13-2018, 06:04 AM)eugeniobcn Wrote:  hola buenas, soy nuevo en el foro  tambien estoy diseñando mi casa domotica desde 0 con arduino, mi proyecto es similar, pero uso telerruptores controlados desde pulsadores y desde arduino para evitar ese problema,  de echo, puedo apagar completamente la electronica  de arduino y la instalacion seguira funcionando al 100%

saludos

Hola Eugeniobcn

Entonces el arduino controla los telerruptores realmente? De manera que en casa tienes una única instalacion hacia el cuadro de telerruptores, y el arduino los ataca a ellos? Buena idea, parece cara (n telerruptores por n circuitos) pero a la larga te ahorrarás problemillas.

Saludos,

Exacto, hay que lanzar 1retorno de cada línea que quieres encender  y de cada pulsador hasta el cuadro dónde se encuentran los Telerruptores, luego mediante  2optocopladores Arduino sabe si una línea está en on o off igual que si el pulsador está en abierto o cerrado de esta manera si pulsamos un pulsador brevemente encendemos si está apagado o viceversa, además si pulsamos largo podemos controlar por ejemplo un driver dimable 1/10v

¿Cómo lo haces con Optoacopladores? Yo he pedido ACS712 para usar de retorno en cada linea de los telerruptores.

uso un diodo 4004 o similar , una resistencia de 220k en serie con el opto  4n33, asi consigo prender el led interno del optp  a 230V de alterna
a la salida del opto te encontraras con una secuencia de 1 y 0 cada  vez que pasa la alterna por -0 sera cero y cuando es mayor de 0 sera 1
esto lo rectifico sencillamente con un electrolitico de 100MF  queda un poco lento en el encendido,  quizas unas centesimas de segundos casi inapreciable,  pero hay que evitar esa fluctuacion no deseada

No es mala opcion sabeis si existe algún telerruptor o biestable de modo que la parte para activarlo la pueda hacer directamente desde el arduino osease 5v vcc y la de potencia lógicamente a 230v ac. Asi si un dia se cae el arduino conecto la pulsación del pulsador de la pared al teleruptor y me salto el arduino hasta que lo cambie teniendo tensión de la fuente de alimentación.
Reply
#14
esto es el primer proto  para un encendido controlado por pulsador a 220v y arduino  a traves de un rele  que activa el telerruptor

   
Reply
#15
(03-13-2018, 10:22 PM)eugeniobcn Wrote:  esto es el primer proto  para un encendido controlado por pulsador a 220v y arduino  a traves de un rele  que activa el telerruptor

agradezco tu respuesta eugeniobcn, el problema es que en la pared voy a colocar unos pulsadores de 12v max los tipicos de 4 patillas microswitch os adjuntare unas fotos ya que ya les tengo hechos.
Reply
#16
lo pense pero solo encontre de 12v , aun asi es mejor usar de 220v yo la instalacion electrica ya la estoy empezando y tan siquiera tengo echo nada de arduino y funciona, osea sin arduino o electronica ninguna la instalacion funciona de modo convencional, cuando tenga la electronica solo tengo que programar para que por ejemplo una pulsacion larga en la entrada de casa me baje todas las persiana y automaticamente me corte todo el suministro electrico de la casa y me cierre una electrovalvula en la entrada de agua, asi cuando salgo de casa me aseguro que todo queda cerrado, tambien podre hacerlo desde el movil o poner la caleffaccon un rato antes de llegar a casa

todo eso no podre hacerlo sin arduino

(03-13-2018, 10:28 PM)TRIP Wrote:  
(03-13-2018, 10:22 PM)eugeniobcn Wrote:  esto es el primer proto  para un encendido controlado por pulsador a 220v y arduino  a traves de un rele  que activa el telerruptor

agradezco tu respuesta eugeniobcn, el problema es que en la pared voy a colocar unos pulsadores de 12v max los tipicos de 4 patillas microswitch os adjuntare unas fotos ya que ya les tengo hechos.

por que usas eso pulsadores?
Reply
#17
(03-13-2018, 10:30 PM)eugeniobcn Wrote:  lo pense pero solo encontre de 12v , aun asi es mejor usar de 220v yo la instalacion electrica ya la estoy  empezando y tan siquiera  tengo echo nada de arduino  y funciona,  osea  sin arduino  o electronica ninguna la instalacion funciona de modo convencional, cuando tenga la electronica solo tengo que programar para que por ejemplo  una pulsacion larga en la entrada de casa me baje todas las persiana y  automaticamente me corte  todo el suministro electrico  de la casa  y me cierre una electrovalvula en la entrada de agua, asi cuando salgo de casa me  aseguro que todo queda cerrado, tambien podre hacerlo desde el movil  o poner  la caleffaccon  un rato antes de llegar a casa

todo eso  no podre hacerlo sin arduino

En un principio yo pensé hacerlo con pulsadores de 220v pero me salia mas caro, al final todas las placas son estandar con 6 pulsadores en cada una como queria hacerles economicos y me salia mucho mas barato con los de 12v pues tire para adelante ya les tengo preparados, mañana en cuanto tengo un ratillo os hago unas fotos y las subo. por eso el combinar las dos tensiones, de hecho el cableado que tirare hasta las placas sera ethernet ya que asi tambien ahorro.
Reply
#18
Buenas a todos a ver el programa le tengo ya mas o menos probado con el envío del cambio de estado de 1 entrada y el accionar una salida por mediación de paquetes udp.

Problema al probar esto, que  me funciona pero  tiene retraso de casi 1 seg y creo que hay algo en la configuracion que me satura de paquetes en elemento remoto y nose el motivo.

A ver si alguno de vosotros podeis echarme una mano y si os convence como esta hecho, ya que es de amateur amateur el como he ido haciéndolo y no se yo.

la verificacion de si hay conexion para despues ejecutar  los void de  envio recepcion de paquetes udp la he anulado porque no me va del todo bien y no sabia si esa era la causa pero al parecer no.

espero vuestros comentarios y ayuda ya que creo que solo no voy a poder.

Un saludo

/********************************************************************************​********************************************************************************​***************************/
/*************************************************************************** PROGRAMA PARA CARTA ARDUINO *************************************************************************/
/*************************************************************************** HABITACION MATRIMONIO *************************************************************************/
/********************************************************************************​********************************************************************************​***************************/

/***********************************************************/
//LIBRERIAS//
#include <SPI.h>
#include <Ethernet2.h>
#include <EthernetUdp2.h> // UDP library from: bjoern@cs.stanford.edu 12/30/2008
#include "DHT.h"
/************************************************************/

/************************************************************/
//DEFINICION DE VARIABLES DHT//
#define DHTTYPE DHT22
#define DHTPIN 2
DHT dht(DHTPIN, DHTTYPE);
/************************************************************/

/************************************************************/
//DEFINICION VARIABLES ETHERNET//
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; //MAC DE LA TARJETA
IPAddress ip(192, 168, 3, 177); // IP DE LA TARJETA ARDUINO
unsigned int localPort = 8888; // local port to listen on
IPAddress ip_remota (192,168,3,6); // IP DEL SERVER LOXONE
unsigned int puerto_remoto = 8889; // puerto remoto del loxone
char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
char ReplyBuffer[] = "acknowledged"; // a string to send back
EthernetUDP Udp; // An EthernetUDP instance to let us send and receive packets over UDP
bool status_udp_ok = 1;
const int N_CARTA = 177; //ULTIMO NUMERO DE LA IP PARA ENVIAR POR UDP EN LOS MENSAJES.
/************************************************************/

/********************************************************************************​*******/
//CONSTANTES DE PINES QUE SERAN UTILIZADOS COMO ENTRADAS//
const int pin3 =3;
const int pin4 =4;
const int pin5 =5;
const int pin6 =6;
const int pin7 =7;
const int pin8 =8;
const int pin9 =9;
const int pin22 =22;
const int pin24 =24;
const int pin26 =26;
const int pin28 =28;
const int pin30 =30;
const int pin32 =32;
const int pin34 =34;
const int pin36 =36;
const int pin38 =38;
const int pin40 =40;
const int pin42 =42;
const int pin44 =44;
const int pin46 =46;
const int pin48 =48;

const int pinA0 =A0;
const int pinA1 =A1;
const int pinA2 =A2;
const int pinA3 =A3;
const int pinA4 =A4;
const int pinA5 =A5;
const int pinA6 =A6;
const int pinA7 =A7;
const int pinA8 =A8;
const int pinA9 =A9;
const int pinA10 =A10;
const int pinA11 =A11;
const int pinA12 =A12;
const int pinA13 =A13;
const int pinA14 =A14;
const int pinA15 =A15;
/********************************************************************************​*******/

/********************************************************************************​*******/
//VARIABLES DONDE SE GUARDA EL STATUS DE LOS PINES DE ENTRADAS//
bool statu_pin3 =0;
bool statu_pin4 =0;
bool statu_pin5 =0;
bool statu_pin6 =0;
bool statu_pin7 =0;
bool statu_pin8 =0;
bool statu_pin9 =0;
bool statu_pin22 =0;
bool statu_pin24 =0;
bool statu_pin26 =0;
bool statu_pin28 =0;
bool statu_pin30 =0;
bool statu_pin32 =0;
bool statu_pin34 =0;
bool statu_pin36 =0;
bool statu_pin38 =0;
bool statu_pin40 =0;
bool statu_pin42 =0;
bool statu_pin44 =0;
bool statu_pin46 =0;
bool statu_pin48 =0;

float statu_pinA0 =0;
float statu_pinA1 =0;
float statu_pinA2 =0;
float statu_pinA3 =0;
float statu_pinA4 =0;
float statu_pinA5 =0;
float statu_pinA6 =0;
float statu_pinA7 =0;
float statu_pinA8 =0;
float statu_pinA9 =0;
float statu_pinA10 =0;
float statu_pinA11 =0;
float statu_pinA12 =0;
float statu_pinA13 =0;
float statu_pinA14 =0;
float statu_pinA15 =0;
/********************************************************************************​*******/

/********************************************************************************​*******/
//CONSTANTES DE PINES QUE SERAN UTILIZADOS COMO SALIDAS//
const int pin23 =23;
const int pin25 =25;
const int pin27 =27;
const int pin29 =29;
const int pin31 =31;
const int pin33 =33;
const int pin35 =35;
const int pin37 =37;
const int pin39 =39;
const int pin41 =41;
const int pin43 =43;
const int pin45 =45;
const int pin47 =47;
const int pin49 =49;
/********************************************************************************​*******/


/********************************************************************************​*******/
//VARIABLES DONDE SE GUARDA EL STATUS DE LOS PINES DE SALIDA//
bool statu_pin23 =0;
bool statu_pin25 =0;
bool statu_pin27 =0;
bool statu_pin29 =0;
bool statu_pin31 =0;
bool statu_pin33 =0;
bool statu_pin35 =0;
bool statu_pin37 =0;
bool statu_pin39 =0;
bool statu_pin41 =0;
bool statu_pin43 =0;
bool statu_pin45 =0;
bool statu_pin47 =0;
bool statu_pin49 =0;


/********************************************************************************​*******/
/************************************** VOID SETUP **********************************/
/********************************************************************************​*******/


void setup() {

/********************************************************************************​*******/
//DESIGNO CADA PIN COMO ENTRADA O COMO SALIDA//

//ENTRADAS//
pinMode(pin3, INPUT);
pinMode(pin4, INPUT);
pinMode(pin5, INPUT);
pinMode(pin6, INPUT);
pinMode(pin7, INPUT);
pinMode(pin8, INPUT);
pinMode(pin9, INPUT);
pinMode(pin22, INPUT);
pinMode(pin24, INPUT);
pinMode(pin26, INPUT);
pinMode(pin28, INPUT);
pinMode(pin30, INPUT);
pinMode(pin32, INPUT);
pinMode(pin34, INPUT);
pinMode(pin36, INPUT);
pinMode(pin38, INPUT);
pinMode(pin40, INPUT);
pinMode(pin42, INPUT);
pinMode(pin44, INPUT);
pinMode(pin46, INPUT);
pinMode(pin48, INPUT);

//SALIDAS//
pinMode(pin23, OUTPUT);
pinMode(pin25, OUTPUT);
pinMode(pin29, OUTPUT);
pinMode(pin31, OUTPUT);
pinMode(pin33, OUTPUT);
pinMode(pin35, OUTPUT);
pinMode(pin37, OUTPUT);
pinMode(pin39, OUTPUT);
pinMode(pin41, OUTPUT);
pinMode(pin43, OUTPUT);
pinMode(pin45, OUTPUT);
pinMode(pin47, OUTPUT);
pinMode(pin49, OUTPUT);
/********************************************************************************​*******/

/********************************************************************************​*******/
// start the Ethernet and UDP:
Ethernet.begin(mac, ip);
Udp.begin(localPort);
dht.begin();
Serial.begin(9600);

/********************************************************************************​*******/

}


/********************************************************************************​*******/
/************************************** VOID LOOP **********************************/
/********************************************************************************​*******/

void loop() {

LECTURA_IN_ARDU (); //EJECUTA EL VOID DE LEER TODAS LAS ENTRADAS DE LA PLACA ARDUINO
LECTURA_OUT_ARDU (); //EJECUTA EL VOID DE LEER TODAS LAS SALIDAS DE LA PLACA ARUDINO
//VERIFICAR_CONEX (); //EJECUTA EL VOID DE VERIFICAR SI HAY CONEXION CON LOXONE

if (status_udp_ok == 1){
ENVIO_IN_UDP_LOXONE ();
ESCRIBE_OUT_UDP_LOXONE ();
}
else if (status_udp_ok == 0){
ESCRIBE_OUT_ARDU ();
}
}
/********************************************************************************​*******/



/********************************************************************************​********************************************************************************​/
/*************************************************************** VOID VERIFICAR_CONX ***********************************************************************/
/********************************************************************************​********************************************************************************​/
/*void VERIFICAR_CONEX (){

if (Udp.beginPacket(ip_remota, puerto_remoto)) //verifica si hay conexion con LOXONE SERVER si la hay pone el status_udp_ok a 1 sino a 0
{
status_udp_ok = 1;
//Serial.println("connected");
// Serial.println(Udp.beginPacket(ip_remota, puerto_remoto));
// Udp.endPacket();
}
else {
status_udp_ok = 0;
Udp.endPacket();
}
}
/********************************************************************************​***********/


/********************************************************************************​********************************************************************************​/
/*************************************************************** VOID LECTURA_IN_ARDU ***********************************************************************/
/********************************************************************************​********************************************************************************​/


/********************************************************************************​********************************************************************************​/

// VOID LEE EL ESTADO DE LOS PINES DE ENTRADAS Y LOS COPIA AL STATU_PINES DE ENTRADAS//
void LECTURA_IN_ARDU (){

digitalRead(pin3);
digitalRead(pin4);
digitalRead(pin5);
digitalRead(pin6);
digitalRead(pin7);
digitalRead(pin8);
digitalRead(pin9);
digitalRead(pin22);
digitalRead(pin24);
digitalRead(pin26);
digitalRead(pin28);
digitalRead(pin30);
digitalRead(pin32);
digitalRead(pin34);
digitalRead(pin36);
digitalRead(pin38);
digitalRead(pin40);
digitalRead(pin42);
digitalRead(pin44);
digitalRead(pin46);
digitalRead(pin48);

analogRead(pinA0);
analogRead(pinA1);
analogRead(pinA2);
analogRead(pinA3);
analogRead(pinA4);
analogRead(pinA5);
analogRead(pinA6);
analogRead(pinA7);
analogRead(pinA8);
analogRead(pinA9);
analogRead(pinA10);
analogRead(pinA11);
analogRead(pinA12);
analogRead(pinA13);
analogRead(pinA14);
analogRead(pinA15);

}
/********************************************************************************​********************************************************************************​/

/********************************************************************************​********************************************************************************​/
/*************************************************************** VOID LECTURA_OUT_ARDU ***********************************************************************/
/********************************************************************************​********************************************************************************​/

/********************************************************************************​********************************************************************************​/

// VOID LEE EL ESTADO DE LOS PINES DE SALIDAS Y LO COPIA AL STATU_PINES DE SALIDAS//

void LECTURA_OUT_ARDU (){

statu_pin23 = digitalRead(pin23);
statu_pin25 = digitalRead(pin25);
statu_pin27 = digitalRead(pin27);
statu_pin29 = digitalRead(pin29);
statu_pin31 = digitalRead(pin31);
statu_pin33 = digitalRead(pin33);
statu_pin35 = digitalRead(pin35);
statu_pin37 = digitalRead(pin37);
statu_pin39 = digitalRead(pin39);
statu_pin41 = digitalRead(pin41);
statu_pin43 = digitalRead(pin43);
statu_pin45 = digitalRead(pin45);
statu_pin47 = digitalRead(pin47);
statu_pin49 = digitalRead(pin49);
}
/********************************************************************************​********************************************************************************​/

/********************************************************************************​********************************************************************************​/
/*************************************************************** VOID ESCRIBE_IN_UDP_LOXONE *****************************************************************/
/********************************************************************************​********************************************************************************​/

/********************************************************************************​********************************************************************************​/
// VOID DE ENVIO HACIA EL LOXONE EL ESTADO DE LOS PINES DE ENTRADAS DE ARDUINO(statu_pinxx)//
void ENVIO_IN_UDP_LOXONE (){

if((statu_pin3 != digitalRead(pin3))&&(statu_pin3 == LOW)){
Serial.println("PIN3 ACTIVO");
Udp.beginPacket(ip_remota,puerto_remoto);
Udp.print ("3_1");
Udp.endPacket();
statu_pin3 = digitalRead(pin3);
Serial.print("statu_pin3=");
Serial.println(statu_pin3);
}

else if((statu_pin3 != digitalRead(pin3))&&(statu_pin3 == HIGH)){
Serial.println("PIN3 NO ACTIVO");
Udp.beginPacket(ip_remota,puerto_remoto);
Udp.print ("3_0");
Udp.endPacket();
statu_pin3 = digitalRead(pin3);
Serial.print("statu_pin3=");
Serial.println(statu_pin3);
}

}
/********************************************************************************​********************************************************************************​/

/********************************************************************************​********************************************************************************​/
/*************************************************************** VOID ESCRIBE_OUT_UDP_LOXONE ****************************************************************/
/********************************************************************************​********************************************************************************​/

/********************************************************************************​********************************************************************************​/
// VOID DE RECIBO DESDE EL LOXONE EL NUEVO ESTADO DE PINES DE SALIDA (PINxx)SEGUN EL ESTADO RECIBIDO POR UDP//
void ESCRIBE_OUT_UDP_LOXONE (){

int packetSize = Udp.parsePacket();
if (packetSize){
Udp.read(packetBuffer,UDP_TX_PACKET_MAX_SIZE);

if ((strncmp(packetBuffer, "pin23=1", 7)==0) && (statu_pin23 == LOW) ) {
digitalWrite (pin23, HIGH);
Serial.println("PIN23 ACTIVO");
}

else if ((strncmp(packetBuffer, "pin23=0", 7)==0) && (statu_pin23 == HIGH)){
digitalWrite (pin23, LOW);
Serial.println("PIN23 APAGADO");
}
}
Udp.endPacket();
}
/********************************************************************************​********************************************************************************​/

/********************************************************************************​********************************************************************************​/
/*************************************************************** VOID ESCRIBE_OUT_ARDU ***********************************************************************/
/********************************************************************************​********************************************************************************​/

/********************************************************************************​********************************************************************************​/
// VOID ESCRIBE EN LOS PINES DE SALIDA (PINxx)SEGUN LOGICA LOCAL PROGRAMADA Y ESTADO DE LAS ENTRADAS LOCALES//
void ESCRIBE_OUT_ARDU (){

}

/********************************************************************************​/
Reply


Forum Jump:


Users browsing this thread: 1 Guest(s)