Show Posts
Pages: [1] 2 3 ... 9
1  International / Français / Re: SCANNER BYTE on: August 03, 2014, 09:10:08 pm
Heu?
Est ce que tu voulais pas faire une suite a une éventuel message "précédent" ? J'ai l'impression d'être complètement hors contexte là.

2  International / Français / Re: Reverse engineering protocole thermopompe hayward on: August 03, 2014, 09:08:08 pm
Oui pas d'inquiétude: je sais que ca risque d'être très compliqué voir impossible à mon niveau. J'avais effectivement suvis les post pour les decodages des blyss.
De mon coté, j'ai déja fait du reverse engenering sur les trames infrarouges de ma télécommande de ma thermo pompe (celle de ma maison cette fois ci). C'est sur que c’était plus simple quoi que quand même...


Après avoir coupé le disjoncteur (sécurité oblige), j'ai pris le temps de démonter soigneusement ma thermopompe et de connecter deux fils: Une pour la masse et un pour la fameuse pin "net". Ensuite j'ai refermé le tout, tout en laissant depasser ces deux câbles la.
Premier test avec un voltmètre, y a bien de la tension qui varie entre 0 et 5v. Ca change tout le temps. C'est bon signe!
Ensuite j'ai branché oscilloscope et j'ai bien un signal numérique TTL.
Par contre y a des données qui sont sans cesse transmise. Y a pas une seconde ou le signal est à 0.
Vu que c'est un vieille oscillo, je n'ai pas pu faire d’acquisition de données.
Par contre j'ai la chance d'avoir le petit analyseur logique opensource vendu par seedstudio.
Dès que j'ai un peu de temps, je commence a essayer de capturer des trames. Par contre, le fait qu'il y ait sans cesse des données transmises je pense que ca va compliquer beaucoup la chose... Comment savoir que ce qui est transmis lorsque je vais appuyer sur un bouton?
Peut être qu'il faut que j'essais de commencer a essayer de comprendre la logique de ce qui est envoyé en continue. D'après moi ca risque d'être:
L'heure, la température de l'eau en entrée, la température en sortie.
En fait c'est ce qu'il y a d'affiché sur l’écran en permanence.

Je vous tiens au courant. Merci



 
3  International / Français / Re: Reverse engineering protocole thermopompe hayward on: August 03, 2014, 07:48:03 am
Merci pour la réponse
je vais essayer de mettre oscilloscope.
Par contre,  ce que je ne comprend pas, c'est que sur le meme fil (net), ca peut envoyer de l'information dans les deux sens?

4  International / Français / Reverse engineering protocole thermopompe hayward on: August 02, 2014, 07:47:15 pm
Bonjour à tous

J'aimerais savoir si certains d'entre vous pourraient m'aider à essayer de faire du reverse engineering sur une carte de contrôle d'une thermo pompe.

Depuis 2 mois, je suis l'heureux propriétaire d'une piscine chauffé. Elle est chauffé par une thermo pompe qui comprend un ecran lcd touchscreen pour la commander.

La première chose que j'ai faite a été de faire des recherches pour voir si quelqu'un avait déja fait cela. Malheureusement ca n'a pas l'air d'être le cas (du moins pour mon modèle) car je n'ai rien trouvé et j'ai vraiment cherché pendant plusieurs semaines. Par contre, ces recherches m'ont appris certaines choses.

Ma thermopome est une:
Trevium HP55TR vendu par Trevi (fabricant de piscine au quebec)
En fait il s'agit d'une Hayward energy line pro. C'est vraiment le même modèle.

Dans la documentation, on peut voir que la carte de crontrole est une PC1000. Voici le schema:




L'interface de contrôle tactile est branché aux 3 pins suivante: 12v, "net" et ground.

Lors de mes recherches, j'ai vu qu'il a existé une carte wifi spécialement conçu par le constructeur, qui pouvait se brancher entre l’écran tactile et ces 3 pins là, justement pour piloter la thermo pompe de manière distante. Malheureusement, cette carte n'est plus fabriqué et plus vendu.

Mes premières interrogations:
Etant donné qu'il y a qu'une seule pin appelé "net", est ce qu'il s'agirait d'une liaison série uni directionnel (clavier vers contrôleur?) Si oui, est ce que cela voudrait dire que si jamais on contrôlait la pompe via la carte wifi, les options choisies comme la température ne se seraient pas mise à jour sur l’écran? J'en doute..

2eme question: Est ce que vous penser que ça peut être un protocole connu? Qui fonctionne avec du 12v?

3eme question: J'ai accès a un oscillo. Est ce que je pourrais essayer de le brancher sur la prise net et bidouiller le clavier pour voir ce qu'il s'y passe?

Merci beaucoup

le lien vers le manuel au cas ou:

http://www.hayward.fr/rokdownloads/chaleur/ntech_energylinepro_fr.pdf
5  International / Français / Re: 2x 74HC595 > et debuggage avec analyseur logique on: January 25, 2014, 06:40:44 pm
Merci

Je n'avais pas compris tout de suite que même si je ne donnais pas de "data" en serie, cela decallait quand même car l'horloge etait active.

Je vais essayer de les mettre en cascade. Mais j'ai du mal a me rendre compte si cela va poser des problèmes pour ma matrice.
En tout j'ai 3 registres à décalage (1 pour les rangé, et 2 pour les colonnes car c'est une matrice BI color)
Donc là je vas essayer de mettre les 3 en cascades sauf que cela va être plus long pour envoyé l'ensembles des données. Est ce que cela ne risque pas d'être trop long et faire un effet de "scintillement" vu que la fréquence de rafraîchissement sera trop faible?

En tout cas, je suis en train de l'essayer. On verra bien
6  International / Français / Re: 2x 74HC595 > et debuggage avec analyseur logique on: January 25, 2014, 10:40:12 am
Merci pour la réponse!

Je l'ai lu au moins 10 fois mais je ne suis pas sur de comprendre à 100%

En fait dès que l'horloge est en marche, cela fait "active" le registre a decalage c'est bien cela? Donc comme l'horloge ce met en marche a cause de la premiere ligne, cela active automatiquement le 2eme? C'est bien cela le problème?

Est ce que pourrais me servir de SRCLR avant d'utiliser le 2eme shift register?

Je vais essayer smiley

EDIT: en fait je me rend compte qu'il me faut donc une autre pin pour gerer cela. Du coup je pourrais la prendre pour rajouter une horloge, ca revient au meme.
7  International / Français / 2x 74HC595 > et debuggage avec analyseur logique on: January 25, 2014, 04:36:35 am
Bonjour

Je suis en train de travailler sur un projet qui va utiliser 2 matrices de led bicolor (à anode commune)
Je travail actuellement sur une breadboard pour voir si mon driver fonctionne.
Pour simplifier, pour le moment j'essaye d'en piloter une seule et je la gère juste comme une matrice d'une seule couleur.
Je fais sur "col scanning":
Mon montage est à base de uln2003 et de 74hc595 (pour piloter les lignes et les colonnes)
Les deux 74hc595 partagent la même horloge et la même latch.
Évidement, leur "serial input" n'est pas la même.


Voici un test de code TRES SIMPLE que j'ai fais:

Code:

int latchPin = 6;
int clockPin = 7;
int colDataPin = 4;
int rowDataPin = 5;


byte index=B10000000;



void setup() {     

Serial.begin(9600);

pinMode(latchPin, OUTPUT);

pinMode(clockPin, OUTPUT);
pinMode(colDataPin, OUTPUT);
pinMode(rowDataPin, OUTPUT);

}



void loop() {
 

digitalWrite(latchPin, 0);

shiftOut(colDataPin, clockPin,MSBFIRST, index);
shiftOut(rowDataPin, clockPin,MSBFIRST, index);

digitalWrite(latchPin, 1);


if(index == B00000001){
index = B10000000;
}else{
index = index >> 1;
}

//Serial.println(index, BIN);

}

Je debugge le tout avec un analyseur logique.
Voici à quoi son branché les pins:

Ch00: clock
Ch01: Serial IN des rangées
Ch02: Sortie QA du 1er registre à décalage
Ch03: Sortie QB du 1er registre à décalage
Ch04: Sortie QC du 1er registre à décalage
Ch05: Sortie QD du 1er registre à décalage
Ch06: Sortie QE du 1er registre à décalage
Ch07: Sortie QF du 1er registre à décalage

Ch08: Serial IN des colonnes
Ch09: Sortie QA du 2eme registre à décalage
Ch10: Sortie QB du 2eme registre à décalage
Ch11: Sortie QC du 2eme registre à décalage
Ch12: Sortie QD du 2eme registre à décalage
Ch13: Sortie QE du 2eme registre à décalage
Ch14: Sortie QF du 2eme registre à décalage

Ch15: Latch pin commune au DEUX registres

Voici le chronogramme:

https://dl.dropboxusercontent.com/u/138037/web/chrono.png


Je ne comprends pas pourquoi celui qui concerne le 2eme registre ne donne pas la même chose que le premier.

Si je change mon code et que je met en commentaire le shiftout des rangées pour ne laisser que celui des colonnes, cette fois ci le 2eme registre donne la bonne chose comme ici:

https://dl.dropboxusercontent.com/u/138037/web/chrono2.png


je ne comprend pas pourquoi le sur le premier, quand les deux shiftout sont ensemble, que les données du 2eme registre a décalage ne sont pas "dealé"

Est ce que quelqu'un est capable de me l'expliquer?

merci beaucoup

8  International / Français / Re: Ouverture de boîte aux lettres ? on: January 06, 2014, 04:44:18 pm
Il y a ca sinon:

http://www.adafruit.com/products/1512
9  International / Français / Re: Branchement matrice led bicolores 8x8 anode commune on: January 04, 2014, 07:46:55 pm
Bon j'ai encore lu beaucoup de chose.
Pouvez vous me dire si j'ai bien compris?

Je ne peux pas utiliser un ULN2003 car à l'interieur c'est un montage de type Darlington, et c'est le collecteur du 2eme transitor qui est en fait la sortie. Le courant "rentre" par le collecteur.
Il faudrait, pour ma matrice a anode commune, utilisé l’émetteur comme sortie pour envoyer le courant aux anodes.

Désolé pour les termes que je dois surement très mal utilisé!

Mais quand je regarde ce site:
http://fightpc.blogspot.ca/2008/03/arduino-mood-light.html
Ca contredit tout ce que je viens de dire....

je suis perdu!
10  International / Français / Re: Branchement matrice led bicolores 8x8 anode commune on: January 04, 2014, 06:17:43 pm
Du coup je ne comprends pas comment on peut brancher cette matrice facilement?

11  International / Français / Re: Branchement matrice led bicolores 8x8 anode commune on: January 04, 2014, 03:21:59 pm
Petite question:
J'ai trouvé plusieurs personnes qui disent qu'un ULN2003 ne peut pas piloter des anodes communes, car a l'intérieur du ULN2003 il s'agit d'un montage darlington avec des PNP.
Pour des anodes communes, il faudrait des NPN.
J'ai compris qu'il y avait une histoire de courran "source" et courant "sink" mais je n'ai pas trop compris.
Est ce quelqu'un est capable de l'expliquer?

merci à vous!
12  International / Français / Re: Branchement matrice led bicolores 8x8 anode commune on: January 04, 2014, 10:52:50 am
Je n'avais pas pensé a chercher sans le mot matrice smiley

Merci! je regarde cela
13  International / Français / Re: Branchement matrice led bicolores 8x8 anode commune on: January 04, 2014, 10:20:53 am
Personne n'en a jamais utilisé des matrices à anode commune?
14  International / Français / Re: Pilotage clim via infra rouge on: January 04, 2014, 10:19:40 am
Voici le code que j'utilise
Mais attention, mon projet utilise deux arduinos:

Le 1er:  Un arduino qui a un module ENCJ qui est branché a mon routeur (qui recoit la temperature a mettre). Il a aussi un module radio NRFL01 qui envoit l'info a l'autre arduino

Le 2eme: L'autre arduino est devant la clim, il revoit l'info de la temperature via le NRFL01
Et ensuite, il construit la trame a envoyé via infrarouge, et il l'envoit.

Ce que je donne comme code, c'est celui du 2eme arduino:


Code:

/*
 Copyright (C) 2012 N. Janik <nicolas.janik@gmail.com>
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.
 */

#include <OneWire.h>
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"
#include "IRremote.h"


#define WORD_TEMP 9
#define WORD_MODE 10
#define WORD_FAN  11
#define WORD_CHECKSUM 16


#define MODE_AUTO 0
#define MODE_COOL 1
#define MODE_DRY  2
#define MODE_FAN  3
#define MODE_HEAT 4


#define FAN_AUTO   0
#define FAN_HIGH   1
#define FAN_MEDIUM 2
#define FAN_LOW    3
#define FAN_QUIET  4


#define FIRST_SPACE 3200
#define FIRST_MARK 1600
#define ONE_IN_MS 1183
#define ZERO_IN_MS 350
#define SPACE_IN_MS 445



//---------------

IRsend irsend;
unsigned char currentTemp;
unsigned char currentMode;
unsigned char currentFan;

unsigned char mode;
unsigned char temp;
unsigned char fan; 


unsigned char trame[16] = {0x28, 0xc6, 0x0, 0x8, 0x8, 0x7f, 0x90, 0xc, 0x7, 0x20, 0x40, 0x0, 0x0, 0x0, 0x4, 0x53};
unsigned char trameOFF[7] = {0x28, 0xc6, 0x00, 0x08, 0x08, 0x40, 0xbf};

unsigned int times[259] = {FIRST_SPACE, FIRST_MARK, SPACE_IN_MS};   //259 = 16 words * (8 bytes + 8 spaces) +  first space + first mark + 1 space in ms
unsigned int timesOFF[115] = {FIRST_SPACE, FIRST_MARK, SPACE_IN_MS};  // 115 =  7 words * (8 bytes + 8 spaces) +  first space + first mark + 1 space in ms


uint32_t timer;

// Radio Hardware configuration
// Set up nRF24L01 radio on SPI bus plus pins 9 & 10

RF24 radio(9,10);

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };





int DS18S20_Pin = 2; //DS18S20 Signal pin on digital 2
//Temperature chip i/o
OneWire ds(DS18S20_Pin);  // on digital pin 2


unsigned long timerTempCheck = 0;
unsigned int roomTemp;

void setup() {               
 
 

 
  pinMode(13, OUTPUT);   
  Serial.begin(9600);
 
 
  printf_begin();
  printf("\n\r INIT \n\r");


  // Setup and configure rf radio

  radio.begin();

  // optionally, increase the delay between retries & # of retries
  radio.setRetries(20,50);

  radio.setPayloadSize(sizeof(unsigned int));


  radio.openWritingPipe(pipes[1]);
  radio.openReadingPipe(1,pipes[0]);


  radio.startListening();

  radio.printDetails(); 


 
}




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


void loop(void)
{
 
 
  //get the room temp every 35 seconds
  if (millis() > timer) {
    timer = millis() + 35000;
    roomTemp = getTemp();
  }
 
 
  // if there is data ready
  if ( radio.available() )
  {
    // Dump the payloads until we've gotten everything
    unsigned int dataCommand;
    bool done = false;
    while (!done)
    {
      // Fetch the payload, and see if this was the last one.
      done = radio.read( &dataCommand, sizeof(unsigned int) );

      // Spew it
      printf("Got payload %i...",dataCommand);
     
     
      // Delay just a little bit to let the other unit
      // make the transition to receiver
      delay(30);     

      // First, stop listening so we can talk
      radio.stopListening();

      switch(dataCommand){
        case 0:
sendOff();
Serial.println("Received OFF command");
        break;
           
        case 9999:
//Serial.println("Ask for temp");
radio.write(&roomTemp, sizeof(unsigned int) );
        break;
           
        default:

            radio.write(&dataCommand, sizeof(unsigned int) );

            Serial.println("default command");
mode = dataCommand / 1000;
temp = (dataCommand / 10) % (mode*100);
fan = dataCommand - ((mode * 1000) + (temp * 10));


Serial.println(dataCommand);
Serial.println("Mode:");
Serial.println(mode);
Serial.println("Temp:");
Serial.println(temp);
Serial.println("Fan:");
Serial.println(fan); 

            setMode(mode);
            setTemp(temp);
            setFan(fan);
            check();
            checksum();
            trameToTime();
            sendIR();

        break;
       }
    }


    // Now, resume listening so we catch the next packets.
    radio.startListening();
  }
 
 
  if(timerTempCheck < millis()){

roomTemp = getTemp();
timerTempCheck = millis() + (1000 * 10);
        Serial.println("Room Temp:");
        Serial.println(roomTemp);
 
  }
}




void sendOff(){


  unsigned char mask;
  unsigned char value;
  int i,j;
  unsigned int index=3;
 

  for(i=0; i<7; i++){
    mask = 0x80;  //10000000
    for(j=0; j<8; j++){

      value = trameOFF[i];

      if(value & mask){
        timesOFF[index++] = ONE_IN_MS;
      }else{
        timesOFF[index++] = ZERO_IN_MS;
      }
      timesOFF[index++] = SPACE_IN_MS;
      mask = mask >> 1;
    }
  }
 
  irsend.sendRaw(timesOFF,115,38);  //38khz

}

void sendCommand(unsigned char mode, unsigned char temp, unsigned char fan){

}

void sendIR(){
  irsend.sendRaw(times,259,38);  //38khz
}


void setFan(unsigned char value)
{
  if(!(value == FAN_AUTO || value == FAN_HIGH || value == FAN_MEDIUM || value == FAN_LOW || value == FAN_QUIET))
  {
    Serial.println("Error setFan: unknown value");
    return;   
  }
 
  currentFan = value;
 
  value = Bit_Reverse(value);
  trame[WORD_FAN-1] = value;
 
 
}


void setMode(unsigned char value)
{
  if(!(value == MODE_AUTO || value == MODE_COOL || value == MODE_DRY || value == MODE_FAN || value == MODE_HEAT))
  {
    Serial.println("Error setMode: unknown value");
    return;   
  } 
 
  currentMode = value;
 
  value = Bit_Reverse(value);
  trame[WORD_MODE-1] = value;
}




void setTemp(unsigned char value)
{
 
  if(value<60 || value>88){
    Serial.println("Error setTemp: Temp not in range (60 to 88)");
    return;
  }
 
  if ( (value & 0x01) != 0) {
    Serial.println("Error setTemp: Temp value must be even");
    return;
  }

  currentTemp = value;

  //60F = 0    61F = 1   ...  88F = 14
  value = (value - 60)/2;
 
 
  value = value << 4;
  value = value & 0xFF;
  value = Bit_Reverse(value);
 
  value = value | 0x80; //set the first bit to 1 to always POWER ON
 
  trame[WORD_TEMP-1] = value;
 

 
}









char checksum(){

  int sum = 0;
  char value;
 
  for(int i=8; i<=15; i++){
    char value = trame[i-1];
    value = Bit_Reverse(value);
    sum+=value;
  }
 
  value = sum % 0xFF;
  value = 0X100 - sum;
  value = Bit_Reverse(value);
 
 
  trame[WORD_CHECKSUM-1] = value;
 

}


void check(){

   if(currentMode == MODE_DRY && currentFan != FAN_AUTO){
        setFan(FAN_AUTO);
   }

}



void trameToTime()
{
 
  unsigned char mask;
  unsigned char value;
  int i,j;
  unsigned int index=3;
 

  check();


  for(i=0; i<16; i++){
    mask = 0x80;  //10000000
    for(j=0; j<8; j++){

      value = trame[i];

      if(value & mask){
        times[index++] = ONE_IN_MS;
      }else{
        times[index++] = ZERO_IN_MS;
      }
      times[index++] = SPACE_IN_MS;
      mask = mask >> 1;
    }
  }
   
}



// Reverse the order of bits in a byte.
// I.e. MSB is swapped with LSB, etc.
unsigned char Bit_Reverse( unsigned char x )
{
    x = ((x >> 1) & 0x55) | ((x << 1) & 0xaa);
    x = ((x >> 2) & 0x33) | ((x << 2) & 0xcc);
    x = ((x >> 4) & 0x0f) | ((x << 4) & 0xf0);
    return x;   
}




float getTemp(){
  //returns the temperature from one DS18S20 in DEG Celsius

//j'ai enlevé le code pour que ca ne soit pas trop long
 
 
}






15  International / Français / Branchement matrice led bicolores 8x8 anode commune on: January 03, 2014, 09:28:11 pm
Bonjour

J'ai terminé il y a quelques semaines mon dernier petit projet arduino (un répéteur de signal infrarouge pour piloter un ampli qui est dans une autre pièce)
Je passe donc à mon prochain petit projet: Une petite horloge.

Pour l'affichage, j'aimerais utilisé les (très peu dispendieuse) matrices à led bicolor 8x8 à anode commune.
J'en ai acheté deux sur ebay pour moins 2$ pièces.
Je pensais que le branchement ne serait pas si compliqué que cela…  Le problème, c’est que c’est une matrice à ANODE commune. Si c’etait à CATHODE commune, j’aurais pu utilisé directement des IC comme le MAX7219CNG (que j’ai acheté avant de comprendre qu’on ne pouvait les utiliser qu’avec des matrices à cathode commune)

Je pensais que j’allais pouvoir trouver un montage facilement sur le web mais finalement, je trouve beaucoup d’informations contradictoires.

Le datasheet de la matrice led:
http://www.b2bledproducts.com/LEDs/GYXM-1388ASRG3.htm

J’ai des 74hc595 en ma possession.

Selon vous, quelle est la meilleure façon de brancher mes 2 matrices sur mon arduino?
Il me faudrait des transistors j’imagine pour pouvoir utiliser toutes les leds en même temps. Je ne pense pas pouvoir utiliser de ULN2003 (encore une fois à cause du fait que ma matrice est a anode commune)

Merci!

Pages: [1] 2 3 ... 9