Pages: [1]   Go Down
Author Topic: Serial Messagerie (cheers Skywodd), carte relais, domotique  (Read 2202 times)
0 Members and 1 Guest are viewing this topic.
0
Offline Offline
God Member
*****
Karma: 0
Posts: 798
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Yep!

Merci skywodd de m'avoir fait découvrir la puissance des pointeurs, il faut vraiment que je m'y mette c kler smiley-wink

J'aimerais piloter mon arduino par le port série et/ou mon afficheur.

Le principe :

<HEADER>;<FLAG><DATA>;<FLAG><DATA>;<FOOT>

Le header pour démarrer la com, classique.
Le flag pour identifier le type de données (int, float, string)
Data, les données à convertir dans leur format respectif ou pas.
Le ";" par exemple pour séparer les données.

Je pensais initialement utiliser la classe string, maintenant, j'ai des doutes... smiley-eek-blue

@+

Zoroastre.
« Last Edit: July 20, 2011, 04:13:15 pm by zoroastre » Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

France
Offline Offline
Faraday Member
**
Karma: 52
Posts: 5341
Arduino Hacker
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Regarde du cote du format csv smiley-wink et aussi de la librairie messenger sur le playground.
Sinon je suis tout à fait d'accord pour te faire un exemple en partant de rien.
Logged

Des news, des tuto et plein de bonne chose sur http://skyduino.wordpress.com !

0
Offline Offline
God Member
*****
Karma: 0
Posts: 798
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Yep!

Merci man.

J'ai déjà un peu regarder la librairie messenger. C'est à peu prés le principe que je voudrais adopté. Cependant, ma difficulté première est que les valeurs que j'envoie à l'arduino puissent être utilisé pour modifier des paramètres à la volée. Deuxième difficulté, les paramètres doivent pouvoir être modifié également par un afficheur glcd tactile.
En gros, je pilote mon installation en local ou distant.

Mon idée première fût donc d'utiliser un tableau de string afin d'ordonner le flôt de donnée. Ensuite, de traiter ces données, les convertir si nécessaire (char to int, char to float) afin qu'elles puissent réguler mon installation, je répete, soit via le pc, soit via l'afficheur.

Je pensais donc transmettre les données vers un autre tableau ou directement vers les variables globales. Le principe restant le même, avec gros avantage pour le tableau tout de même d'avoir une lecture, me semble-t'il, plus aisée.

Pour parler un peu de mon projet, il s'agit en priorité d'un thermostat programmable avec diverses fonctions, modes de fonctionnement : auto (là pas de souci), off (ok), absence (en heures), vacances (en jours + heures).
Je prévois également de pouvoir ajuster des températures, coefficients (float).

J'avais envisager de mettre aussi un caractère NULL (pas de modif), genre '*', afin de traiter et cibler plus rapidement les changements d'état.

Petite précision, je récupère l'horloge avec la bibliothèque time, que j'inclue en premier lieu dans la trame.
Et du côté pc, python que je maitrise un peu mieux que le c.

J'ai donc plein d'idée qui fourmille dans ma tête.

Firmata ne me convient pas, messenger ne me semble pas convenir, le xpl est réseau, je veux du seriel ! Csv, je potasse demain, là je suis naze...

Je joins également le code trés trés brouillon qui englobe mes premiers essais dans cette direction.

Code:
/*

THIS CODE WORKS GOOD !

Simple Message system arduino/serial pc
1 - Clock update
2 - Send Log
3 - Retrieve data
The goal is to have a synchronized table with index

1 - {START BIT}
2 - {DIRECTION SEND/RECEIVE 0/1} // OPTIONAL
# BEGIN OF DATA
3 - {MODE AUTO/AWAY/VACANCY/OFF} // 0, 1, 2, 3
4 - {A FLOAT}
5 - {AN INT }
6 - {A CHAR}
# END OF DATA
7 - {STOP BIT}

*/

#include <string.h>
#include <stdlib.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Time.h>

#define ONE_WIRE_BUS 3
#define TEMPERATURE_PRECISION 10

#define TIME_MSG_LEN  11
#define TIME_HEADER  'T'
#define TIME_REQUEST  7

#define DATA_HEADER '*'
#define DATA_REQUEST '!'

#include <OneWire.h>
#include <DallasTemperature.h>
#include <Time.h>

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

uint8_t indoor[8] = {0x28, 0xFC, 0x97, 0x56, 0x2, 0x0, 0x0, 0x69};

// STUCT_LENGHT =  {1, 2345, 67, 8} <8>
const int lenA = 1;
const int lenB = 4;
const int lenC = 2;
const int lenD = 1;

float tempC0;
int _minute, last_minute;

// index for server message array
int  serveIn;
char serveInString[20];
int  serveInIndx  = 0;
int  serveOutIndx = 0;

// index for time array
int  timeIn;            
char timeInString[12];  
int  timeInIndx  = 0;
int  timeOutIndx = 0;


void setup() {
Serial.begin(9600);
sensors.begin();
sensors.requestTemperatures();
//setSyncProvider(requestSync);
//first request of time
if(timeStatus() == timeNotSet)
  {
      processSyncTime();
  }
}

void loop() {
  
delay(2000);

//request time if needed
if(timeStatus() == timeNotSet)
  {
      processSyncTime();
  }
// set time vars
int _hour = (hour());
int _minute = (minute());
int current_time = (_hour*60) + _minute;

delay(2000);

processSyncMsg();

// print log every minute
if (_minute != last_minute)
{
  sensors.requestTemperatures();
  tempC0 = sensors.getTempC(indoor);
  last_minute = _minute;
  Serial.print(_hour);
  Serial.print(":");
  Serial.print(_minute);
  Serial.print("|");
  Serial.print(current_time);
  Serial.print("|");
  Serial.print(tempC0);
  Serial.println("°C");
}

delay(1000);

}

/*
// index for server message array
int  serveIn;
char serveInString[20];
int  serveInIndx  = 0;
int  serveOutIndx = 0;
*/

void processSyncTime() {
  readTimeFromServer();
  Serial.print(TIME_REQUEST,BYTE);
  printTimeFromServer();
}

void processSyncMsg() {
  readMessageFromServer();
  Serial.print(DATA_REQUEST);
  printMessageFromServer();
}

void readMessageFromServer() {
    int sb;  
    if(Serial.available()) {
       Serial.print("reading Server String: ");     //optional confirmation
       while (Serial.available()){
          sb = Serial.read();            
          serveInString[serveInIndx] = sb;
          serveInIndx++;
//          Serial.write(sb);                        //optional confirmation
       }
       Serial.println();
    }  
}

void readTimeFromServer() {
    int sb;  
    if(Serial.available()) {
       Serial.print("reading Time String: ");     //optional confirmation
       while (Serial.available()){
          sb = Serial.read();            
          timeInString[timeInIndx] = sb;
          timeInIndx++;
//          Serial.write(sb);                        //optional confirmation
       }
       Serial.println();
    }  
}

void printTimeFromServer() {
  if( timeInString > 0) {
    Serial.print("Arduino memorized TIME: ");
    if ((timeInString[0] == TIME_HEADER)) {
       time_t pctime = 0;    
      //loop through all bytes in the array and print them out
      for(timeOutIndx=0; timeOutIndx < TIME_MSG_LEN -1; timeOutIndx++) {
        Serial.print(timeInString[timeOutIndx]);    //print out the byte at the specified index          
        if( int(timeInString[timeOutIndx]) >= '0' && int(timeInString[timeOutIndx]) <= '9'){  
          pctime = (10 * pctime) + (int(timeInString[timeOutIndx]) - '0') ; // convert digits to a number    
        }
      }
      setTime(pctime);   // Sync Arduino clock to the time received on the serial port

          }
    }
      // reset array
      timeOutIndx = 0;
      timeInIndx  = 0;
      //Serial.println();
}

void printMessageFromServer() {
  if( serveInString > 0) {
    Serial.print("Arduino memorized MESSAGE: ");
    if ((serveInString[0] == DATA_HEADER)) {
       int A = serveInString[1] - '0';
       char B[lenB - 1];  // array 0 to 3 = 4
       int j;
       for(serveInIndx=2, j=0; serveOutIndx < 6, j < lenB; serveOutIndx++, j++) {
          B[j] =  serveInString[serveOutIndx]; }
          char C = serveInString[6];
          Serial.print(A);
          Serial.print(" | ");
          Serial.print(B);
          Serial.print(" | ");
          Serial.print(C);
          Serial.print(" | ");
          // put code after B print
          char *Bunit, *Bdecimal, *r;
          // unité
          Bunit = strtok_r(B , ".", &r);
          // decimal
          Bdecimal = strtok_r(NULL , ".", &r);
         // int a = atoi(Bunit);
          float a = atoi(Bunit);
          float b = atoi(Bdecimal);
          float result = a + (b/100);
          Serial.print("Float=");
          Serial.print(Bunit);
          Serial.print(":");
          Serial.print(Bdecimal);
          Serial.print(" | ");
          Serial.print("Result=");
          Serial.print(result);
          Serial.print(" | ");
          float pi = 3.14159;
          Serial.print(pi);
    }
  }
      // reset array
      serveOutIndx = 0;
      serveInIndx  = 0;
      //Serial.println();
}


« Last Edit: July 12, 2011, 05:50:02 pm by zoroastre » Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

0
Offline Offline
God Member
*****
Karma: 0
Posts: 798
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Reprenant le même principe, j'ai commencé à écrire la même chose en usant de la classe string...

Code:
// STRUCTURE OF MESSAGE
String comString[16]; // string array of 16 lines
char buffer; // buffer for incoming
int lenCom; // lenght of comString

void setup() {
Serial.begin(9600);
sensors.begin();
sensors.requestTemperatures();
}

void loop() {
  syncRoutine();
  delay(2000);
}

void syncRoutine(){
  if(Serial.available()) {
    while(Serial.available() < 1) { //read first byte
      buffer = Serial.read();
      if (buffer == DATA_NOSYN || comString[0] == DATA_NOSYN) { // NO UPDATE
        Serial.println("LOG : SYNC OK - No Update");
        break;
      }
      if (buffer == DATA_SYN_ARD || comString[0] == DATA_SYN_ARD) { // PC NEED TO SEND NEW UPDATE
        readMessageFromServer(buffer, sizeof(buffer));
      }
      if (buffer == DATA_SYN_PC || comString[0] == DATA_SYN_PC) { // PC NEED TO RECEIVE UPDATE
        sendMessageFromArduino();
      }
      else {Serial.println("LOG : NO SYNC..."); // NO SYNC
      }
    }
  }
}

boolean updateFromServer() {
  if (Serial.available()) {
    Serial.println(HEARTBEAT);
    while(Serial.available() < 1) { //read first byte
      buffer = Serial.read();
      if ((buffer == HEARTBEAT) && (timeStatus() != timeNotSet)) {
        return false;}
      if (buffer == DATA_SYN_ARD) {
        return true;}
      if ((buffer == HEARTBEAT) && (timeStatus() == timeNotSet)) {
        return true;}
  }
  }
}

void readMessageFromServer(char buffer, int bufsize) {
  int i= 0;
  String line = "";
    while (Serial.available()){
      buffer = Serial.read();
      for (i = 0; i < bufsize; i++) {
            // SEPARATOR
        if (buffer == SEPARATOR) {buffer = '\0'; comString[i] = line; line = ""; i++; }
            // END OF BUFFER
        if (buffer == DATA_END) {buffer = '\0'; comString[i] = line; line = ""; lenCom = i; }
        else {line.concat(buffer); }
      }
    }
    Serial.println();
}

void sendMessageFromArduino() {
}

Mais effectivement, là, j'ai l'impression de me compliquer la tache...Je pourrais simplifier déjà la partie afficheur en activant un flag hors message qui déclencherait l'envoi de la trame vers le pc pour sauvegarde.
Finalement, le code du post précedant me semble peut-être plus viable. A force de vouloir prendre en compte tous les cas de figure, je finis par me perdre et multiplier inutilement les codes.

@+

Zoroastre.
« Last Edit: July 12, 2011, 06:06:26 pm by zoroastre » Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

0
Offline Offline
God Member
*****
Karma: 0
Posts: 798
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Yep!

Bon, j'insiste dans la nom utilisation de la classe string, consommatrice de mémoire sur ce que j'ai pû lire ici et là smiley-wink
Code:
#define HEARTBEAT '*'
#define ENDMSG '!'
#define SEPARATOR ';'
#define BUFFERSIZE 32

char buffer[BUFFERSIZE + 1];

void setup() {
  Serial.begin(9600);
}

void loop() {
  if (getSerialString()) {
    checkdata(buffer, sizeof(buffer));
  }
 delay(2000);
}

boolean getSerialString(){
    static byte dataBufferIndex = 0;
    boolean storeString;
    while(Serial.available()>0){
        char incomingbyte = Serial.read();
        if(incomingbyte==HEARTBEAT){
            dataBufferIndex = 0;  //Initialize our dataBufferIndex variable
            storeString = true;
        }
        if(storeString){
            //Let's check our index here, and abort if we're outside our buffer size
            //We use our define here so our buffer size can be easily modified
            if(dataBufferIndex==BUFFERSIZE){
                //Oops, our index is pointing to an array element outside our buffer.
                dataBufferIndex = 0;
                break;
            }
            if(incomingbyte==ENDMSG){
                buffer[dataBufferIndex] = 0; //null terminate the C string
                //Our data string is complete.  return true
                return true;
            }
            else{
                buffer[dataBufferIndex++] = incomingbyte;
                buffer[dataBufferIndex] = 0; //null terminate the C string
            }
        }
        else{
        }
    }
  
    //We've read in all the available Serial data, and don't have a valid string yet, so return false
    return false;
}
  
void checkdata(char *buffer, int bufsize) {
  char *p = buffer;
  char *str;
  while ((str = strtok_r(p, ";", &p)) != NULL) { // delimiter is the semicolon
    Serial.println(str);}
}

Il faudrait maintenant faire correspondre les données scindées avec une structure définies, afin d'attribuer et convertir chaque données vers les variables utiles. En premier lieu, j'aimerais supprimer du traitement le caractère '*' (HEARTBEAT)...

@+

Zoroastre.

Petite modif afin de supprimer le HEARTBEAT :

Code:
...
if(Serial.available() > 1){
        char incomingbyte = Serial.read();
        if(incomingbyte==HEARTBEAT){
            dataBufferIndex = 0;  //Initialize our dataBufferIndex variable
            storeString = true;
        }
        if(storeString){
          while(Serial.available()>0){
            char incomingbyte = Serial.read();
...

« Last Edit: July 15, 2011, 03:56:20 am by zoroastre » Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

0
Offline Offline
God Member
*****
Karma: 0
Posts: 798
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Je tatonne, je tatonne...

Nouvelle modif :

Code:
...
void checkdata(char *buffer, int bufsize) {
  char *p = buffer;
  char *str;
  int i = 0;
  while ((str = strtok_r(p, ";", &p)) != NULL) { // delimiter is the semicolon
    char *q = str;
    variables[i] = q;
    i++;
    Serial.println(str);}
}
...

et ajout de confirmation dans le loop...

Code:
Serial.println(variables[0]);
Serial.println(variables[1]);

J'ai donc bien les données qui apparaissent dans le moniteur.

Mais j'aimerais bien que quelqu'un m'expique ce que je viens de faire, n'ayant qu'un apercu trés limité des pointeurs, et savoir si les variables ainsi déclarées sont exploitables ???

@+

Zoroastre.

complete code :

Code:
/*
Le 15/07/2011
STATUS : WORK
*/

#define HEARTBEAT '*'
#define ENDMSG '!'
#define SEPARATOR ';'
#define BUFFERSIZE 32

char buffer[BUFFERSIZE + 1];
char* variables[6];

void setup() {
  Serial.begin(9600);
}

void loop() {
  if (getSerialString()) {
    checkdata(buffer, sizeof(buffer));
  }
  Serial.println(variables[0]);
  Serial.println(variables[1]);
 delay(2000);
}

boolean getSerialString(){
    static byte dataBufferIndex = 0;
    boolean storeString;
      if(Serial.available() > 1){
        char incomingbyte = Serial.read();
        if(incomingbyte==HEARTBEAT){
            dataBufferIndex = 0;  //Initialize our dataBufferIndex variable
            storeString = true;
        }
        if(storeString){
          while(Serial.available()>0){
            char incomingbyte = Serial.read();
            //Let's check our index here, and abort if we're outside our buffer size
            //We use our define here so our buffer size can be easily modified
            if(dataBufferIndex==BUFFERSIZE){
                //Oops, our index is pointing to an array element outside our buffer.
                dataBufferIndex = 0;
                break;
            }
            if(incomingbyte==ENDMSG){
                buffer[dataBufferIndex] = 0; //null terminate the C string
                //Our data string is complete.  return true
                return true;
            }
            else{
                buffer[dataBufferIndex++] = incomingbyte;
                buffer[dataBufferIndex] = 0; //null terminate the C string
            }
          }
        }
        else{
        }
    }
  
    //We've read in all the available Serial data, and don't have a valid string yet, so return false
    return false;
}
  
void checkdata(char *buffer, int bufsize) {
  char *p = buffer;
  char *str;
  int i = 0;
  while ((str = strtok_r(p, ";", &p)) != NULL) { // delimiter is the semicolon
    char *q = str;
    variables[i] = q;
    i++;
    Serial.println(str);}
}

Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

0
Offline Offline
God Member
*****
Karma: 0
Posts: 798
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Yep!

Je poste mes résultats. Ils pourront peut être servir smiley-wink

Le sketch :
Code:
/*
############################################################################
Le 16/07/2011
SIMPLE SERIAL COMMUNICATION with Startbit, separator and Endbit.

Include librairie Time.
############################################################################
*/

#include <Time.h>

#define HEARTBEAT '*'
#define ENDMSG '!'
#define BUFFERSIZE 32
#define TIME_REQUEST  7
#define TIME_MSG_LEN  11

char buffer[BUFFERSIZE + 1];
char* TRAME[3];

int _hour = (hour());
int _minute = (minute());
int current_time = (_hour*60) + _minute;
int last_minute;
/*
############################################################################
GLOBAL : ZONE TEST
############################################################################
*/
float anything;
int anything2;
/*
############################################################################
SETUP - SETUP - SETUP - SETUP - SETUP - SETUP - SETUP - SETUP - SETUP
############################################################################
*/
void setup() {
Serial.begin(9600);
delay(2000);
Serial.println("LOG : setup complete");
}
/*
############################################################################
LOOP - LOOP - LOOP - LOOP - LOOP - LOOP - LOOP - LOOP - LOOP - LOOP
############################################################################
*/
void loop() {
  _hour = (hour());
  _minute = (minute());
  current_time = (_hour*60) + _minute;

  if (timeStatus() == timeNotSet) { Serial.println(TIME_REQUEST, BYTE); }
  if(getSerialString()) { Serial.println(buffer); filldata(buffer); checkdata();}

  if (_minute != last_minute) {
    last_minute = _minute;
    sendLogs();
  }
}
/*
############################################################################
SECTION : LOOK AND MANAGE INCOMING SERIAL MESSAGE
############################################################################
The getSerialString function looks for a valid message, with a header and a foot.
if message is valid, it is split to each TRAME spaces in filldata function.
The delay is needed to ensure receiving, depending on buffer lenght.
############################################################################
*/
boolean getSerialString() {
  int dataBufferIndex = 0;
  boolean storebuffer = false;
  delay(50);
  if(Serial.available() > 1) {
    while(Serial.available()) {
      char incoming = Serial.read();
      delay(50);
      if(incoming == HEARTBEAT) {dataBufferIndex = 0; storebuffer = true;}
      if(storebuffer) {
        if(dataBufferIndex == BUFFERSIZE){dataBufferIndex = 0; break; }
        if(incoming == ENDMSG) {buffer[dataBufferIndex] = 0; dataBufferIndex = 0; storebuffer = false; return true; }
        else { buffer[dataBufferIndex++] = incoming;}
      }
    }
  }
  return false;
}

void filldata(char *buffer) {
  char *p = buffer;
  char *str;
  int i = 0;
  while ((str = strtok_r(p, ";", &p)) != NULL) { // delimiter is the semicolon
    char *q = str;
    TRAME[i] = q;
    i++;
//    Serial.println(str);
  }
}

void checkdata() {
  // The char '#' means NOCHANGE
  if (TRAME[0][1] != '#') { updateTime(); } // TIME
  if (TRAME[1] != "#") { anything2 = string2integer(TRAME[1]); } // MENU MODE
  if (TRAME[2] != "#") { anything = string2float(TRAME[2]); }
  else { }
}

void updateTime() {
  int i = 0;
  time_t pctime = 0;    
  //loop through all bytes in the array and print them out
  for(i = 0; i < TIME_MSG_LEN; i++) {
    //Serial.print(TRAME[0][i]);    //print out the byte at the specified index          
      if( int(TRAME[0][i]) >= '0' && int(TRAME[0][i]) <= '9'){  
        pctime = (10 * pctime) + (int(TRAME[0][i]) - '0') ; // convert digits to a number    
        }
      }
      setTime(pctime);   // Sync Arduino clock to the time received on the serial port
}
/*
############################################################################
SECTION : CONVERT STRING TO SOMETHING
############################################################################
*/
int string2integer(char* data) {
  //int value = data - '0';
  int value = atoi(data);
  return value;
}

float string2float(char* data) {
  char *unite, *decimal, *r;
  float value;
  unite = strtok_r(data , ".", &r);
  decimal = strtok_r(NULL , ".", &r);
  float u = atoi(unite);
  float d = atoi(decimal);
  value = u + (d/float(10));
  return value;
}
/*
############################################################################
SECTION : SERIALY PRINT LOGS
############################################################################
*/
void sendLogs() {
  Serial.print("Il est ");
  Serial.print(_hour);
  Serial.print(":");
  Serial.print(_minute);
  Serial.print(" soit la ");
  Serial.print(current_time);
  Serial.println("eme minute de la journée.");
  Serial.print("Les consignes sont fixée à : ");
  Serial.print(anything2);
  Serial.print(" | ");
  Serial.println(anything);
  Serial.println("#########################################################");
}

Le jeton python :
Code:
import serial, time

ser = serial.Serial('/dev/ttyUSB0',9600)

def update_time():
    tic = time.time() - time.timezone + time.daylight*3600
    tics = '*' + str(tic)[0:10] + ';1;17.2!'
    ser.write(tics)

while 1:
    data = ser.readline()
    if data[0:1] == '\7' :
        update_time()
        time.sleep(0.1)
        print "RECEIVED"
    if data :
        print data


J'ai pris soin de tester avec le moniteur et envoyer : *#;#;15.5!
->Resultat impec ! seule la troisième valeur est modifiée.

Il y a certainement des améliorations à apporter...

Merci pour ce retour à la simplicité skywodd  smiley-lol

@+

Zoroastre.
« Last Edit: July 17, 2011, 05:50:19 pm by zoroastre » Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

0
Offline Offline
God Member
*****
Karma: 0
Posts: 798
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Yep!

J'avance à grand pas désormais.

Il me reste à implémenter un afficheur tactile, multiplier les sondes de température dans différentes pièces de la maison, et tester une sonde PIR. Ajuster les longueurs de cable, écrire une interface python conviviale...

Mon labo  smiley-yell  smiley-yell  smiley-yell



@+

Zoroastre.
« Last Edit: July 19, 2011, 11:51:28 am by zoroastre » Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

Offline Offline
Full Member
***
Karma: 0
Posts: 111
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

A quoi sert la rs845, on ne peut pas utiliser directement la platine relay ?
Logged

0
Offline Offline
God Member
*****
Karma: 0
Posts: 798
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Yep!

Le chip RS485 sur le board est inversé, elle communique avec un ATTINY2313 pour gérer les 8 canaux/relais.

Sachant que l'arduino ne parle pas RS485 ou même RS232 naturellement, il faut donc lui donner cette faculté via un chip supplémentaire. On utilise ici une topologie mirroir.



Je possède deux cartes relais actuellement, elles possèdent chacunes une adresse individuelle et me permet de piloter sur un seul bus série un nombre important de relais avec une distance maximale théorique de 1200 mètres.
Petite précision, je n'utilise pas les lignes de résistances à 470 ohms pour le moment. Elles doivent être utiles sur de longue distance (pull up) et comme je ne suis qu'en phase de test, je n'ai pas encore éprouvé les longues distances.



Plus d'info ici : http://www.sigma-shop.com/category/12/rs485.html

@+

Zoroastre.
« Last Edit: July 20, 2011, 08:39:14 am by zoroastre » Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

Offline Offline
Full Member
***
Karma: 0
Posts: 174
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

sympatique ce montage ! ça ouvre pas mal de possibilité pour faire de la domotique smiley
Logged

Offline Offline
Full Member
***
Karma: 0
Posts: 111
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

J ai pris celle-la :
http://www.sigma-shop.com/product/63/eight-relay-board-ready-for-your-pic-avr-project-5v.html

j ai branche les ports de 0 à 7 de la duemalove dessus en correspondant au 1 à 8 de la carte, avec le gnd de l arduino au ground de la carte

j ai bien tous les relais qui s enclenchent par contre, problèmes rencontrés :
le programme se bloque au bout de plusieurs secondes
l affichage de l horloge prends 2 secondes de saut

les relais correspondant au 0/1 de l arduino s'enclenche au démarrage (alimentation) de l arduino, (je pense que la redirection de l'utilisation des ports n est pris en compte qu au démarrage du programme), par contre je ne m explique pas le reste
Logged

0
Offline Offline
God Member
*****
Karma: 0
Posts: 798
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Yep!

Ton GND est-il bien en contact ? As-tu ponté tout les GND de l'arduino ensemble ?

Tu as un shema de ton montage ??

Tu peux également contacter le forum de KMTronics, il est trés réactif, englais obligatoire par contre.

@+

Zoroastre.

Quote
PS : Je viens de voir que tu as déjà contacté le forum smiley-wink
« Last Edit: July 20, 2011, 09:17:11 am by zoroastre » Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

Offline Offline
Full Member
***
Karma: 0
Posts: 111
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
As-tu ponté tout les GND de l'arduino ensemble ?

c est à dire ?

j ai pris le gnd coté sortie digital que j ai mis en relation du gnd de la relay board, en sachant que les 2 gnd du relay board sont identiques

pas de schéma, mais je ferais une photo ce soir
Logged

0
Offline Offline
God Member
*****
Karma: 0
Posts: 798
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Yep!

Quote
Cela permet de n'avoir qu'UN point de référence pour LES divers montages RELIES entre eux.
Des masses DIFERENTES engendrent (parfois) des différence de potentiels entre ces masses, qui PERTURBENT le bons fonctionnement des montages suivant leur "suceptibilité" (sensibilité) de leurs "entrées".

Quand je joue avec le GND de mon arduino où est relié la carte relais, cette dernière se transforme en guirlande de noël, elle clignote dans tous les sens. C'est la raison pour laquelle, j'evoque cette possibilité.

L'ideal est de relier toutes les masses de ton arduino, même si à priori tu ne les utilises pas toutes.

@+

Zoroastre.
Logged

Veuillez indiquer [RESOLU] dans l'entête du titre en éditant votre premier message smiley-wink

Pages: [1]   Go Up
Jump to: