next topic »

[Reply #285 on:]

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.

Code:

#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);
}

[Reply #286 on:]

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.

[Reply #287 on:]

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.

[Reply #288 on:]

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 ?

[Reply #289 on:]

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

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.

[Reply #290 on:]

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

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.

@+

[Reply #291 on:]

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

[Reply #292 on:]

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).

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é.

@+

[Reply #293 on:]

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.

[Reply #294 on:]

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

[Reply #295 on:]

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 ?

[Reply #296 on:]

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.

[Reply #297 on:]

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.

[Reply #298 on:]

Yop yop,
Vive les boiboites bien propre histoire de cacher un montage dégueulasse (les miens).  
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é) :

Code:

#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);
}

[Reply #299 on:]

Page index html:

Code:

<!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>
 <br></br>
 <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:

Code:

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+="<br>"+msg;
}

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

Code php:

Code:

<?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).