Aidez nous ! Projet - Gestion domotique

Brisebee:

osaka: 2 ème icone à partir de la gauche au dessus des smileys : [img ] url /img

Merci pour ta réponse

Ce qui signifie qu'il faut avant de poster, déposer l'image sur un autre site. Je pensai qu'il était possible de la déposer sur le forum (comme pour une pièce jointe).

Connais-tu un site simple et pratique pour déposer les images, sans être noyé de spam et messages publicitaires ?

Vi il te faut héberger tes images, moi ici j'utilise le petit espace que me fournit mon provider avec mon abonnement adsl (normalement ils fournissent tous un petit espace ?). Sinon il y a http://imageshack.us/ .

;)

Merci osaka

Bon je vais voir, c'est peut-être aussi simple de les mettre en pièce jointe.

Je vais arrêter de polluer ce forum avec cette question.

@+

Brisebee: Non je n'ai pas testé ce module, je n'ai pas encore décidé si je vaiment mettre en oeuvre les 6 ordres. Je crois que Skuzmitoo l'a simulé et peut-être même testé en vrai, tu trouveras des infos à ce sujet dans ce sujet vers les pages 9 ou 10, pour ce qui concerne le coût il suffit de voir sur un site comme sélectronic, conrad ou autre mais cela ne va pas chercher bien loin, le plus cher et aussi le plus encombrant sera le transfo.

Merci pour les infos, je posais la question du cout si tu avais déjà fait le truc en plusieurs exemplaire. Comme il m'en fait 14, cela peut vite chiffrer... C'est pour cela que je regarde les module de télécommande de prise RF (20 euros les 4) qui vont surement être moins chère, et plus fiable (je ne veux pas "jouer" avec le 220) Je continue mes recherches et je vous tiendrais au courant.

L'idée de prendre un système RF existant, est certainement intéressante, surtout pour éviter de tirer des câbles. Il reste à voir la faisabilité en terme de portée des liaisons RF, très probablement que tes radiateurs sont dans des pièces différentes, il faut alors voir comment placer l’Arduino qui va commander les différents canaux des télécommandes. Peut-être en position centrale ? Ce sera effectivement avec grand intérêt que je suivrai tes essais. @+

Je viens de commander un "Idk Kit Silver / 1 télécommande + 4 prises 1000 Watts" C'est 20 euros chez auchan pour 4 prises.

Je pensais prendre un kit 12 prises comme celui ci http://www.nasasafe.com/12ch-ac110240v-31543mhz-wireless-remote-control-switch-1-transmitter-to-12-receivers-4-control-modes_p117.html C'est plus chère, et c'est pas garantis que cela fonctionne avec le librairie rc-switch... par contre il y a 12 modules de la bonne taille.

alors que le kid ldk, j'ai vu qu'une personne l'avait déjà testé avec le rc-swicth. Par contre, il va falloir que je démonte les prises pour les rentrer dans la cassette des chauffages.

Pour les tests, J'ai plus qu'a attendre que tout arrive... l'arduino vient de france, mais le module RF vient de Chine...

Yop yop,

Je viens de faire le teste sans crc et apparemment celui-ci prend entre 400 et 500µs pour 5octet c’est fort raisonnable je trouve.

Dernière version de mon code de teste pour un module 8 I/O avec commande locale.

#include <util/crc16.h>
#include <util/delay.h>
#include <avr/wdt.h>

#define DATA_LENGTH 6
#define ADDRESS 0x10
#define RE_DE_ON PORTC|=8
#define RE_DE_OFF PORTC&=~(8)
#define RE_DE_REG DDRC |= 8
#define BAUD 115200

#define _WAIT(_pres) _delay_us(_pres)

#define SERIAL_BUFFER_SIZE 10
volatile uint8_t pos = 0;
volatile uint8_t bufferBusRx[SERIAL_BUFFER_SIZE];


volatile uint8_t listener = 0;
volatile uint32_t delayWD = 0;

uint8_t bufferBusTx[DATA_LENGTH] = {0}; 


const uint32_t pres = 69120000/BAUD; //temps de maintien RE_DE
const uint32_t maxRec = 14000000/BAUD; //temps max en reception
const uint32_t maxTrans = (32640000/(BAUD/100))+((ADDRESS*(pres*2))); //temps max de transaction+ temps different entre module selon l'adresse ( donc priorité ascendante en cas de colision, etc)

volatile uint8_t* sortieReg[8] = {&PIND, &PIND, &PIND, &PIND, &PIND, &PIND, &PINB, &PINB}; //correspondance registre/sorie n° (préféré à une structure conditionnel)
uint8_t sortieBit[8] = {4, 8, 16, 32, 64, 128, 1, 2}; //correspondance bit/registre/sortie n°

uint32_t delayB = 0;

ISR(USART_RX_vect)
{
  if((UCSR0B & (1<<RXB80))) // si bit9 à 1 = adresse
  {
    listener = UDR0;
    if(listener == ADDRESS) //s'il sagit de son adresse
    {
      UCSR0A &= ~(1<<MPCM0);
      pos = 0;
    }
    else //sinon toute donnees transitant sur le bus seront ignore
    {
      UCSR0A |= (1<<MPCM0);
    }
    
    delayWD = micros()+maxTrans; //on active un delay max d'occupation du bus quelque soit l'emeteur ou ecouteur
  }
  else //si mode écoute entrante, on enregistre les donnees
  {
    if(pos <= 8) // temps que les 8 octet n'on pas été reçu (t'aille constante spécifique à la trame module I/O 8)
    {
      bufferBusRx[pos] = UDR0;
      ++pos;
    }
    else
    {
      pos = 0;
    }   
  }
}


////////////////////////////////////////////////////////////////////////////

void setup()
{
  RE_DE_REG; //pin RE_DE en sortie
  
  DDRD |= 252; //reg D 11111100 en sortie
  DDRB |= 3;   // reg B 00000011 en sortie
  
  DDRB &= ~(60); // reg B 00111100 en entrée
  DDRC &= ~(15); // reg C 00001111 en entree
  begin(BAUD); //init
  
  PORTD|=252;
  PORTB|=3;
  _delay_ms(1000);
  PORTD&=~(252);
  PORTB&=~(3);
}

void loop()
{ 
  if(pos == 8) //si donnees entrente
  {
    readData();
    pos = 0;
  }
  else //sinon on verifie s'il y a des donnee a transmettre dans le buffer
  {
    sendData();
  }
  
  uint8_t bIO = ((PINB&60)>>2)+((PINC&15)<<4); //registre pour commande en entrée (locale)
  if(bIO&255 && micros() >= delayB)
  {
    for(byte i=0; i < 8; i++)
    {
      if(bIO&(1<<i))
      {
        if(*(sortieReg[i])&(sortieBit[i]))
        {
          bufferBusRx[4] = 0x00;
        }
        else
        { 
          bufferBusRx[4] = 0x01;
        }
       
        bufferBusRx[5] = i;
        action(1);  
      }
    }
    delayB = micros()+250000;
  }
}

uint8_t sendData()
{
  if(bufferBusTx[2] && !listener) // si données à transmettre bufferBusTx[2] (! 0) et que le bus est libre (0)
  {
    _WAIT(pres); //petite pause de sécurité car même en cas de liberation '0', RE_DE peux encore être maintenu de l'autre côté
    writeData(1); //on envois les données
  }
  
  if(listener && micros() >= delayWD) // si delay de transaction max est dépasse donc erreur, collision, etc
  {                                   //  delayWD aura une valeur différente pour chaque adresses
    listener = 0x00;
  }
}

void readData() // reception
{
    if(bufferBusRx[0] == 0x02 && bufferBusRx[8] == 0x03) //debut de trame
    {
        if(checkData()) //crc ok
        {
          action(0);

        }
        else //sinon on retourne directement un message d'erreur crc à l'envoyeur
        {
          
          ackError(0x02);
        }
    }
    else //sinon on retourne directement un message d'erreur general de reception
    {
      ackError(0x01);
    }
     
}

void action(uint8_t local)
{
    if(bufferBusRx[4]==0x00) // out on
    {
      *(sortieReg[bufferBusRx[5]]+2) &= ~(sortieBit[bufferBusRx[5]]); //PORTX &= ~(bit)
    }
    else if(bufferBusRx[4]==0x01) //out off
    {
      *(sortieReg[bufferBusRx[5]]+2) |= sortieBit[bufferBusRx[5]];
    }
    
    bufferBusTx[0] = 0x05;
    bufferBusTx[1] = 0x80;
    bufferBusTx[2] = ADDRESS;
    bufferBusTx[3] = 0xFF;
    bufferBusTx[4] = bufferBusRx[5];
    bufferBusTx[5] = ((PIND >> 2)+(PINB << 6)); //retour d'etat des 8 sorties
    
    if(!local)
    {
      _WAIT(pres); //petite pause de sécurité car même en cas de liberation '0', RE_DE peux encore être maintenu de l'autre côté
      writeData(0);
    }    
}

void writeData(uint8_t local)
{
  //calcul du crc en premier
  uint16_t crc = 0xFFFF;
  
  for(uint8_t i=0; i <= bufferBusTx[0]; i++)
  {
    crc = _crc16_update(crc, bufferBusTx[i]);
  }
  
  //active le mode transmition
  RE_DE_ON;
  
  write(bufferBusTx[1], 1); //adressage
  write(0x02, 0); //debut de trame
  for(uint8_t i=0; i <= bufferBusTx[0]; i++) //donnees (suivant la taille specifiée)
  {
    write(bufferBusTx[i], 0);
  }
  
  write(((crc & 0xFF00) >> 8), 0); //crc MSB
  write((crc & 0x00FF), 0); //crc LSB
  write(0x03, 0); //fin de trame
  if(local)
  {
    write(0x00, 1);
  }
  _WAIT(pres); //delay de maintien 
  RE_DE_OFF; // on desacive le mode de transmition
  bufferBusTx[2] = 0;
}

uint8_t checkData() //controle crc
{
  uint16_t crc = 0xFFFF;
  
  uint16_t _crc = (bufferBusRx[6]<<8);
  _crc += bufferBusRx[7];
  
  for(uint8_t i=1; i <= bufferBusRx[1]+1; i++)
  {
    crc = _crc16_update(crc, bufferBusRx[i]);    
  }

  if(crc == _crc)
  {
    return 1;
  }
  
  return 0;
}

void ackError(uint8_t ErrorNo)
{
  bufferBusTx[0] = 0x04; 
  bufferBusTx[1] = 0x81;
  bufferBusTx[2] = ADDRESS;
  bufferBusTx[3] = 0xFE;
  bufferBusTx[4] = ErrorNo;
  _WAIT(pres);
  writeData(0);
}

//////////////////////////////////////////////////////////////////////////////////////////////////

void write(uint8_t data, uint8_t txb8)
{
  while (!((UCSR0A) & (1 << UDRE0)))
    ; 
  if(txb8)
  {
    UCSR0B |= (1<<TXB80);
  }
  else
  {   
    UCSR0B &= ~(1<<TXB80);
  }
  UDR0 = data;
}

void begin(unsigned long baud)
{
  uint16_t baud_setting;

  UCSR0A = 0;
  baud_setting = (F_CPU / 8 / baud - 1) / 2;

  UBRR0H = baud_setting >> 8;
  UBRR0L = baud_setting;
    
  UCSR0B = (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0)|(1<<UCSZ02);
  UCSR0C = (3<<UCSZ00);
  
  UCSR0A |= (1<<MPCM0);
}

Yep!

Je suis tombé sur çà en faisant un petit peu de lèche vitrine chez mes sites marchands habituels :

(http://www.sigma-shop.com/product/73/web-internet-ethernet-controlled-relay-board-arduino-compatible-rs485-usb-boxed-for-din-mount-rail.html)

Cà donne des idées $)

@+

Zoroastre.

Oui Zoroastre, c'est effectivement très sympa, bon 4 Entrées et 4 sorties c'est un peu limité, mais comme le microcontrôleur en a bien plus, il doit y avoir moyen de faire quelque chose pour y accéder. Pour un module à distance cela peut-être très intéressant. Je pense à un autre projet que celui qui nous réuni sur ce sujet du forum.

J’ai commencé mes essais du bus I2C avec 2 PCF8574, l’un en entrée l’autre en sortie, ça marche nickel avec un câble de plus de 4 mètres, c'est-à-dire presque trois fois ce qu’il me faut (j’ai sous estimé la distance de mon unité de commande de chauffage, elle est à environ 1,50m). Ce soir, je vais voir pour faire quelques essais en milieu perturbé; je vous tiens au courant.

J'ai fait des essais avec le câble de 4m sur le bus I2C en créant des perturbations : - avec un vieux moteur électrique qui crache des étincelles => pas de Pb - en enclenchant un gros contacteur => l'afficheur LCD du système affiche n'importe quoi, alors que le bus I2C fonctionne bien.

conclusion : je pense que pour ma liaison I2C à 1,5m cela devrait bien fonctionner => je vais utiliser un câble blindé pour plus de sécurité.

Qu'en pensez-vous ?

zoroastre:

Au final c'est le rendu (version close) que j'aimerais obtenir (rail DIN) par module. :open_mouth:

Brisebee: Qu'en pensez-vous ?

De ce que j'ai vu, entendu ça ne devrait pas posé de problème ? Zoro y répondra mieux que moi je pense.

osaka: Au final c'est le rendu (version close) que j'aimerais obtenir (rail DIN) par module. :open_mouth:

J'ai déja utilisé ce type de boîtier : mon unité de commande chauffage est monté dans un tel boîtier et je viens d'en commander d'autres chez Conrad pour les unités d'interfaçage chauffage et arrosage.

@+

Brisebee: J'ai déja utilisé ce type de boîtier : mon unité de commande chauffage est monté dans un tel boîtier et je viens d'en commander d'autres chez Conrad pour les unités d'interfaçage chauffage et arrosage.

J'ai pas vu de module arduino chez conrad. Tu parles juste de la boite ?

Sinon, vous savez, cela existe une jolie boite bien propre, pouvant contenir un arduino, un afficheur LCD , quelques boutons. (et si possible avec de la place pour une sheild "radio" radio RF ou wifi ou autres pour la liaison avec les autres modules) Pour faire une interface de commande chauffage pour mettre dans le salon ? Il faudrait que cela ressemble à un truc comme cela, par exemple http://www.conrad.fr/thermostat_avec_programmation_hebdomadaire_24_230v_p_52080_59631_836555_648169_FAS

cedric2: J'ai pas vu de module arduino chez conrad. Tu parles juste de la boite ?

Oui je parle du boîtier. Effectivement Conrad ne fait pas de modules Arduino.

Je posterai des photos au fur et à mesure. Pour l'instant je ne peux faire que celles des unités de commandes (puisqu'elles existent et fonctionnent avec mon ancien système).

cedric2: Sinon, vous savez, si cela existe une jolie boite bien propre, pour faire une interface de commande chauffage pour mettre dans le salon ?

Je n'ai jamais vu, mais je n'ai pas cherché.

@+

Bonjour a tous et toutes, moi j'ai utilise ce genre de boitier. et d'autre boitier pour Rail DIN http://www.tme.eu/fr/katalog/?art=Z-104#id_category%3D100625%26cleanParameters%3D1%26%26page%3D5%2C20 Site en pologne mais prix des boitier OK. A plus.

Cela a l'air pas mal et pas cher. (j'ai pas vu les frais de livraison) Il faut que je recherche encore un peu, et que je valide les taille, mais http://www.tme.eu/fr/details/abs-33a/boitiers-pour-appareils-a-ecran/# me semble pas mal adapté si je trouve un afficheur adaptable

Merci pour l’info, ces boîtiers ont l’air d’être bien adaptés pour la domotique, autant ceux pour rails DIN, qui sont à priori pas trop chers, que les autres. Il faut effectivement voir pour les frais de port, si quelqu’un a l’info ?

Les frais de livraison sont de 7,90€, livraison par UPS. Mes commandes on été reçu 3-4 jours après payement par paypal.

J'ai commander ce boitier et je suis satisfait de cellui-ci.

je l'utilise pour 32 entrées et un autre pour 16 sortie avec relais.

Yop yop,
Vive les boiboites bien propre histoire de cacher un montage dégueulasse (les miens). :grin:
Sinon pour changer un peux j’ai remis mon shield eth sur ma mega, pour la partie couplage contrôleur web/bus, j’arrive à envoyer une commande avec retour de statut assé rapidement (une 20 ène de millis sec, avec bus à 112500baud).
Par contre je suis moyennement satisfait au niveau de la réactivité en ce qui concerne les commande local et statut je suis obligé de scruter tout les x ms si il y à eu un changement c’est loin d’être optimal.
Je met mon code d’expérimentation.

Code arduino (brouillon pas propre et non optimisé) :

#include <SPI.h>
#include <Ethernet.h>
#include <util/crc16.h>
#include <util/delay.h>
#include <avr/wdt.h>

#define DATA_LENGTH 6
#define ADDRESS 0x12
#define RECEIVER 0x10

#define RE_DE_ON PORTK|=128
#define RE_DE_OFF PORTK&=~(128) 
#define RE_DE_REG DDRK |= 128
#define BAUD 115200

#define _WAIT(_pres) _delay_us(_pres)
#define SERIAL_BUFFER_SIZE 16

byte mac[] = {  0x90, 0xA2, 0xDA, 0x00, 0x6D, 0x86 };
byte ip[] = { 192,168,1,109 };

Server server(9390);
Client client = 0;

volatile uint8_t listener = 0;
volatile uint32_t delayWD = 0;

uint8_t bufferBusTx[DATA_LENGTH] = {0}; 
volatile uint8_t bufferBusRx[SERIAL_BUFFER_SIZE] = {0};
volatile uint8_t bufferTmp[32] = {0};
volatile uint8_t pos = 0;
volatile uint8_t available = 0;

uint32_t delayB = 0;
volatile uint8_t ack = 0;
uint8_t err = 0;

const uint32_t pres = 69120000/BAUD;
const uint32_t maxRec = 14000000/BAUD;
const uint32_t maxTrans = (32640000/(BAUD/100))+((ADDRESS*(pres*2)));


ISR(USART1_RX_vect)
{
  if((UCSR1B & (1<<RXB81)))
  {
    listener = UDR1;
    if(listener == ADDRESS || listener == 0x80 || (ack && listener == 0x81))
    {
      UCSR1A &= ~(1<<MPCM1);
      pos = 0;
      available = 0;
    }
    else
    {
      UCSR1A |= (1<<MPCM1);
    }
    
    delayWD = micros()+maxTrans; 
  }
  else
  {
    bufferBusRx[pos] = UDR1;
    
    if(pos == bufferBusRx[1]+4)
    {
      available = pos;
      pos = 0;
    }
    else
    {
      ++pos;
    }
  }
}

////////////////////////////////////////////////////////////////////////////

void setup()
{
  Ethernet.begin(mac,ip);
  server.begin();
  delay(1000);
  
  RE_DE_REG;
  DDRK &= ~(64);
  
  begin(BAUD);
}

////////////////////////////////////////////////////////////////////////

void loop()
{
  client = server.available();
  if(client.available()) 
  {
    int i = 0;
    while(client.available() > 0)
    {
      bufferBusTx[i] = client.read();
      i+=1;
    }
    
    if(bufferBusTx[1] == 0x12 && bufferBusTx[2] == 0x12)
    {
      if(bufferTmp[2])
      {
        writeAjax(client, bufferTmp);
          
        bufferBusTx[2] = 0;
        bufferTmp[2] = 0;
      }
    }
    else
    {
      while(client.connected())
      {
        if(available)
        {
          readData(); 
          available = 0;
        }
        else
        {
          sendData();
        }   
      }
    }
    client.flush();
    client.stop();
  }
  
  if(available)
  {
    readData();   
    available = 0; 
  }
  else
  {
    sendData();
  }
  
}

uint8_t sendData()
{
  if(bufferBusTx[2] && !listener) 
  {
    _WAIT(pres);
    writeData(bufferBusTx);
    ack = 1;
  }
  
  if(listener && micros() >= delayWD) 
  {
    listener = 0x00;
    ack = 0;
  }
}

void readData() 
{
    if(bufferBusRx[0] == 0x02 && bufferBusRx[bufferBusRx[1]+4] == 0x03) //debut de trame
    {
        if(checkData()) //crc ok
        {
          action();
        }
        else //sinon on retourne directement un message d'erreur crc à l'envoyeur
        {
          
          ackError(0x02);
        }
    }
    else //sinon on retourne directement un message d'erreur general de reception
    {
      ackError(0x01);
    }
       
}

void action()
{ 
    if(bufferBusRx[4] == 0xFF || err == 2)
    {
      bufferBusTx[2] = 0;
      _WAIT(pres);
      RE_DE_ON;
      write(0x00, 1);
      _WAIT(pres);
      RE_DE_OFF;
      ack = 0;
      err = 0;
      if(bufferBusRx[4] == 0xFF)
      {
        if(client.connected())
        {
          writeAjax(client, bufferBusRx);
        }
        else
        {
          for(int i = 0; i <= bufferBusRx[1]+1; i++)
          {
            bufferTmp[i] = bufferBusRx[i];
          }
        }
      }
    }    
    else
    {
      ++err;
      _WAIT(pres);
      writeData(bufferBusTx);
    }
}

void writeAjax(Client cli, volatile uint8_t* buf)
{
    client.print("{");

    for(int i = 0; i <= buf[1]; i++)
    {
      client.print("\"i");
      client.print(i);
      client.print("\":");
      client.print((int)buf[i+1]);
      if(i < buf[1])
      {
        client.print(",");
      }
    }
    client.print("}");
    
    client.flush();
    client.stop();
}

void writeData(uint8_t* data)
{
  uint16_t crc = 0xFFFF;
  
  for(uint8_t i=0; i <= data[0]; i++)
  {
    crc = _crc16_update(crc, data[i]);
  }
  
  RE_DE_ON;
  
  write(data[1], 1); 
  write(0x02, 0); 
  for(uint8_t i=0; i <= data[0]; i++) 
  {
    write(data[i], 0);
  }
  
  write(((crc & 0xFF00) >> 8), 0);
  write((crc & 0x00FF), 0);
  write(0x03, 0); 
  _WAIT(pres); 
  RE_DE_OFF;
}

uint8_t checkData()
{
  uint16_t crc = 0xFFFF;
  
  uint16_t _crc = (bufferBusRx[bufferBusRx[1]+2]<<8);
  _crc += bufferBusRx[bufferBusRx[1]+3];
  
  for(uint8_t i=1; i <= bufferBusRx[1]+1; i++)
  {
    crc = _crc16_update(crc, bufferBusRx[i]);    
  }

  if(crc == _crc)
  {
    return 1;
  }
  
  return 0;
}

void ackError(uint8_t ErrorNo)
{
  uint8_t data[5] = {0};
  data[0] = 0x04; 
  data[1] = 0x81;
  data[2] = ADDRESS;
  data[3] = 0xFE;
  data[4] = ErrorNo;
  _WAIT(pres);
  writeData(data);
}
//////////////////////////////////////////////////////////////////////////////////////////////////

void write(uint8_t data, uint8_t txb8)
{
  while (!((UCSR1A) & (1 << UDRE1)))
    ; 
  if(txb8)
  {
    UCSR1B |= (1<<TXB81);
  }
  else
  {   
    UCSR1B &= ~(1<<TXB81);
  }
  UDR1 = data;
}

void begin(uint32_t baud)
{
  uint16_t baud_setting;
  UCSR1A = 0;
  baud_setting = (F_CPU / 8 / baud - 1) / 2;

  UBRR1H = baud_setting >> 8;
  UBRR1L = baud_setting;
    
  UCSR1A |= (1<<MPCM1);
  UCSR1B = (1<<RXEN1)|(1<<TXEN1)|(1<<RXCIE1)|(1<<UCSZ12);
  UCSR1C = (3<<UCSZ10);
  UCSR1B &= ~(1<<UDRIE1);
}

Page index html:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>DDuinoAjax</title>

    <link href="http://ajax.googleapis.com/ajax/libs/jqueryui/1.8/themes/base/jquery-ui.css" rel="stylesheet" type="text/css"/>
    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.5/jquery.min.js"></script>
    <script src="http://ajax.googleapis.com/ajax/libs/jqueryui/1.8/jquery-ui.min.js"></script>
        
    <script src="webAjax.js"></script>
    <script src="response.js"></script>
    
   <link rel="stylesheet" type="text/css" href="style.css" media="screen" />

</head>
<body onload="init()">
 <h3>DD</h3>
 <div id="log"></div>
 


 <div><button id="dw0" onclick="digitalWrite(0, 1, 1)">on</button></div>
 <div><button id="dw1" onclick="digitalWrite(1, 1, 1)">on</button></div>
 <div><button id="dw2" onclick="digitalWrite(2, 1, 1)">on</button></div>
 <div><button id="dw3" onclick="digitalWrite(3, 1, 1)">on</button></div>
 <div><button id="dw4" onclick="digitalWrite(4, 1, 1)">on</button></div>
 <div><button id="dw5" onclick="digitalWrite(5, 1, 1)">on</button></div>
 <div><button id="dw6" onclick="digitalWrite(6, 1, 1)">on</button></div>
 <div><button id="dw7" onclick="digitalWrite(7, 1, 1)">on</button></div>
 
</body>
</html>

Code javascript:

function init()
{
	setInterval("getStatut()", 200);
}

function getStatut()
{
  var dataJSon = {"0":0x02,"1":0x12,"2":0x12 };
  send(dataJSon);
}

function parseJSon(dJson)
{
  var duino = eval('(' + dJson + ')');
  if(duino.i2 == 0x10)
  {
    log(dJson);
    for(var i = 0; i <= 7; i++)
    {
      id="dw"+i;
    
      if(duino.i5 & (1 << i))
      {
        $(id).innerHTML="off";
        $(id).setAttribute('onclick', "cmdIO("+i+", 0, 0)");
      }
      else
      {
        $(id).innerHTML="on";
        $(id).setAttribute('onclick', "cmdIO("+i+", 1, 0)");
      }
      //log(Date.now());
    }
  }
}

function cmdIO(pin, value, ack)
{
  //log(Date.now());
  var dataJSon = {"0":0x04,"1":0x10, "2":0x12, "3":value, "4":pin };
  send(dataJSon);
}

function send(dataJSon)
{
  jQuery.post("socket.php", dataJSon,
  function(data)
  {
    parseJSon(data);
  });
}

function $(id)
{
  return document.getElementById(id);
}

function log(msg)
{
  $("log").innerHTML+="
"+msg;
}

function sleep(milliseconds)
{
  var start = new Date().getTime();
  start+=milliseconds;
  
  while((new Date().getTime()) <= start)
  {
      
  } 
}

Code php:

<?php

$msg = "";
$buffer = null;

foreach($_POST as $element)
{
 $msg=$msg.chr($element);
}

$host="192.168.1.109";
$port=9390;

$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
socket_connect($socket, $host, $port);
socket_write($socket,$msg,strlen($msg));

do
{
    if(isset($buffer))
        echo $buffer;
}
while(@socket_recv($socket,$buffer,32,0) != 0);

socket_close($socket);

?>

Je songe à revenir vers les websocket mais serveur en java et communication avec le bus non plus avec shield eth mais via port serie du serveur (hard).