Go Down

Topic: 4shiftregisters temp et humidité? (Read 1 time) previous topic - next topic

Moilion

Bonjour,

Voilà, comme la plupart des nouveaux j'ai adapté un code trouvé sur le net pour contrôler des afficheurs 7 segment avec un shiftregister (74hc595).

Je l'ai couplé avec un dht11, et par miracle, j'affiche la température ( 2 jours d'essais)  :smiley-red: (vous l'aurez compris je suis très nul, mais bon, j'essaye de faire...).

Maintenant, je désirerais ajouter 2 afficheurs, donc 2 shift registers de plus en cascade afin que ces derniers m'affichent l'humidité, j'ai bien essayé mais je pense que mon erreur est de ne pas être capable de déclarer que:

- J'ai 4 shift register
- 2 sont alloués à la température
- 2 sont alloués à l'humidité

Car pour l'instant si j'ajoute le même programme mais avec une fonction lire l'humidité (les 2 nombres s'affichent en alternance sur les 2 afficheurs 7 segments (humidité/temp).

ma question sera donc, enfin on y arrive comment puis-je déclarer dans le code que j'ai 4 shift register dont 2 servent à l'affichage de la température et 2 à l'affichage de l'humidité?

La solution la plus simple serait de connecter 2 shift register (donc 3 fils) et deux autres indépendant shift register, ce qui me ferait 6 fils aux sorties de l'arduino, et je voudrais garder 3 fils en sortie...
Est-ce possible?
Si oui comment?


voici le code:


Code: [Select]
#include "DHT.h"

#define DHTPIN 2     // what pin we're connected to


#define DHTTYPE DHT11   // DHT 11


DHT dht(DHTPIN, DHTTYPE);


/*
  Driving multiple 7-seg displays with 74HC595 shift registers.
 
  Feel free to re-use.
 
   01/30/2010
*/

const int  g_pinCommLatch = 6;
const int  g_pinClock     = 7;
const int  g_pinData    = 5;

// Definitions of the 7-bit values for displaying digits
byte g_digitstemp[10];

// Current number being displayed
int g_numberToDisplay = 0;

// Number of shift registers in use
const int g_registerstemp = 2;

// Array of numbers to pass to shift registers
byte g_registerArraytemp [g_registerstemp];




void setup() {
  Serial.begin(9600);
  Serial.println("DHTxx test!");

  dht.begin();
 
  pinMode (g_pinCommLatch, OUTPUT);
  pinMode (g_pinClock, OUTPUT);
  pinMode (g_pinData, OUTPUT);
 
 
 
  // Setup the digits array
  // a = 8 b = 4 c = 2 d = 64 e = 32 f = 1 g = 16
  g_digitstemp [0] = 8 + 4 + 2 + 64 + 32 + 1;
  g_digitstemp [1] = 4 + 2;
  g_digitstemp [2] = 8 + 4 + 16 + 32 + 64;
  g_digitstemp [3] = 8 + 4 + 16 + 2 + 64;
  g_digitstemp [4] = 1 + 16 + 4 + 2;
  g_digitstemp [5] = 8 + 1 + 16 + 2 + 64;
  g_digitstemp [6] = 8 + 1 + 16 + 2 + 64 + 32;
  g_digitstemp [7] = 8 + 4 + 2;
  g_digitstemp [8] = 8 + 4 + 2 + 64 + 32 + 1 + 16;
  g_digitstemp [9] = 8 + 4 + 2 + 1 + 16 + 64;
} // setup

// Simple function to send serial data to one or more shift registers by iterating backwards through an array.
// Although g_registers exists, they may not all be being used, hence the input parameter.
void sendSerialData (
  byte registerCount,  // How many shift registers?
  byte *pValueArray)   // Array of bytes with LSByte in array [0]
{
  // Signal to the 595s to listen for data
  digitalWrite (g_pinCommLatch, LOW);
 
  for (byte reg = registerCount; reg > 0; reg--)
  {
    byte value = pValueArray [reg - 1];
   
    for (byte bitMask = 128; bitMask > 0; bitMask >>= 1)
    {
      digitalWrite (g_pinClock, LOW);
   
      digitalWrite (g_pinData, value & bitMask ? HIGH : LOW);
       
      digitalWrite (g_pinClock, HIGH);
    }
  }
  // Signal to the 595s that I'm done sending
  digitalWrite (g_pinCommLatch, HIGH);
}  // sendSerialData







void loop() {
  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  // check if returns are valid, if they are NaN (not a number) then something went wrong!
  if (isnan(t) || isnan(h)) {
    Serial.println("Failed to read from DHT");
  } else {
    Serial.print("Humidity: ");
    Serial.print(h);
    Serial.print(" %\t");
    Serial.print("Temperature: ");
    Serial.print(t);
    Serial.println(" *C");
  }
 
 
  {
  g_numberToDisplay = dht.readTemperature();
 
  if (g_numberToDisplay < 10)
  {
    g_registerArraytemp [3] = g_digitstemp [0];
    g_registerArraytemp [2] = g_digitstemp [0];
    g_registerArraytemp [1] = g_digitstemp [0];
    g_registerArraytemp [0] = g_digitstemp [g_numberToDisplay];
  }
  else if (g_numberToDisplay < 100)
  {
    g_registerArraytemp [3] = g_digitstemp [0];
    g_registerArraytemp [2] = g_digitstemp [0];
    g_registerArraytemp [1] = g_digitstemp [g_numberToDisplay / 10];
    g_registerArraytemp [0] = g_digitstemp [g_numberToDisplay % 10];
  }
  else if (g_numberToDisplay < 1000)
  {
    g_registerArraytemp [3] = g_digitstemp [0];
    g_registerArraytemp [2] = g_digitstemp [g_numberToDisplay / 100];
    g_registerArraytemp [1] = g_digitstemp [(g_numberToDisplay % 100) / 10];
    g_registerArraytemp [0] = g_digitstemp [g_numberToDisplay % 10];
  }
  else
  {
    g_registerArraytemp [3] = g_digitstemp [g_numberToDisplay / 1000];
    g_registerArraytemp [2] = g_digitstemp [(g_numberToDisplay % 1000) / 100];
    g_registerArraytemp [1] = g_digitstemp [(g_numberToDisplay % 100) / 10];
    g_registerArraytemp [0] = g_digitstemp [g_numberToDisplay % 10];
  }

  sendSerialData (g_registerstemp, g_registerArraytemp);
}
}


je pensais :

Code: [Select]
/*
  Driving multiple 7-seg displays with 74HC595 shift registers.
 
  Feel free to re-use.
 
   01/30/2010
*/

const int  g_pinCommLatch = 6;
const int  g_pinClock     = 7;
const int  g_pinData    = 5;

// Definitions of the 7-bit values for displaying digits
byte g_digitstemp[10];

// Current number being displayed
int g_numberToDisplay = 0;

// Number of shift registers in use
const int g_registerstemp = 2;
const int g_registershum = 2;

// Array of numbers to pass to shift registers
byte g_registerArraytemp [g_registerstemp];
byte g_registerArrayhum [g_registershum];



Mais c'est normal, je ne déclare pas que j'ai 4 shift register, enfin soit...

un grand merci d'avance

skizoh

Hum alors je vais pas réussir à te répondre d'un coup mais je vais essayer de rassembler les infos ça mâchera le travaille ^^

Alors donc

4 shift register pour 4 afficheurs 7 seg
2 shift register de déclaré uniquement

si j'ai bien compris tu sais juste pas déclarer les shift register et tu ne sais pas non plus ou tu précise quel shift register tu utilise?

Par ce que si c'est que ça je pense que la déclaration c'est ici:

Quote

const int  g_pinCommLatch = 6;
const int  g_pinClock     = 7;
const int  g_pinData    = 5;

const int  g_pinCommLatch2 = 9;
const int  g_pinClock2     = 10;   //<====================
const int  g_pinData2    = 8;

  pinMode (g_pinCommLatch, OUTPUT);
  pinMode (g_pinClock, OUTPUT);
  pinMode (g_pinData, OUTPUT);

  pinMode (g_pinCommLatch2, OUTPUT);
  pinMode (g_pinClock2, OUTPUT);    //<============================================
  pinMode (g_pinData2, OUTPUT);



et après à chaque fois que tu utilisais les afficheur la tu rajout 2 dans le nom

68tjs

Quote
comment puis-je déclarer dans le code que j'ai 4 shift register dont 2 servent à l'affichage de la température et 2 à l'affichage de l'humidité?

Ce n'est pas comme cela qu'il faut prendre le probleme.
Un shiftregister registres à décalage peut être soit utilisé seul ou chaîné en série avec d'autres.

Ce qui signifie pour ton cas :

Solution 1 : 2 groupe de registres indépendants
Coté matériel : les deux groupe de registres sont totalement indépendants, ce qui demandera 2 broches d'horloges différentes et deux broches de données différentes, le latch verrou peut être commun. Soit 5/6 broches au total.
Coté logiciel : les deux groupes de registre à décalages sont totalement indépendants et se gèrent chacun de leur coté.
. Il suffit d'écrire une fonction pour gérer la chose.
Solution 2 : 4 registres chaînés
Coté matériel : la sortie du premier registre est connectée sur l'entrée données du second et ainsi de suite.
3 broches seront suffisantes horloge commune aux registres, donnée en entrée du premier registre et verrou commun aux registres.
Coté logiciel : Chaque fois que tu aura à modifier ne serait-ce qu'un seul bit il faudra obligatoirement recharger tous les registres.

Le code découlera du mode de fonctionnement choisi.



fdufnews

Quote
Je l'ai couplé avec un dht11, et par miracle, j'affiche la température ( 2 jours d'essais)  smiley-red (vous l'aurez compris je suis très nul, mais bon, j'essaye de faire...).

Pas si nul puisque ça marche.

Quote
Maintenant, je désirerais ajouter 2 afficheurs, donc 2 shift registers de plus en cascade afin que ces derniers m'affichent l'humidité, j'ai bien essayé mais je pense que mon erreur est de ne pas être capable de déclarer que:

Là tu as brulé une étape.
Maintenant que ça marche (ou que c'est tombé en marche), il faut reprendre calmement le schéma du montage d'un coté et le code de l'autre et comprendre pourquoi/comment  ça marche. Un morceau de code s'applique à une configuration particulière, si on comprend comment fonctionne le montage alors on peut le faire évoluer plus facilement. Il ne faut pas s'arrêter à la petite victoire du "ça marche".

Par exemple
T'es-tu demandé pourquoi il y avait cette déclaration dans le programme que tu as utilisé:
Code: [Select]
// Number of shift registers in use
const int g_registerstemp = 2;

Si tu comprends le pourquoi de cette ligne ainsi que le schéma du montage associé, peut être que tu vas comprendre comment extrapoler ton montage à un nombre quelconque d'afficheurs. 68tjs t'as déjà donné une partie de la solution.

Moilion

Merci,

J'ai compris qu'il suffit de déclarer 4 registres à décalage , donc:

- changer le 2 en 4.

Mais comment dois-je faire pour "dire" les 2 premiers seront liés à la température tandis que les 2 autres serviront pour l'affichage de l'humidité?

68tjs

Un avis qui n'engage que moi.
Un travail aussi basique que ça c'est l'occasion d'apprendre le b.a.ba pour se débrouiller tout seul plus tard et ne pas  être à la remorque de bouts de programmes tout faits récupérés par ci par là et rarement compatibles entre eux.
Un effort au début et la tranquillité plus tard vaut mieux que la facilité au début et toujours la galère plus tard.

La base :
Le 74hc595 est un registre à décalage de 8 bits ce qui, et ce n'est pas un hasard, fait tout juste un octet.
Dans la programmation arduino il existe la fonction ShiftOut(x,x,x,x) qui permet d'envoyer un octet bit par bit et c'est ce qu'il faut pour écrire dans un registre à décalage.
La fonction ShiftOut est expliquée soit sur le site arduino soit en français sur le site /www.mon-club-elec.fr
http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.ShiftOut


Ton application :
Tu met 4 registres à décalage en série donc il te faut préparer 4 octets et les envoyer dans le bon ordre les uns à la suite des autres.
Ce n'est pas plus compliqué que cela.
ShiftOut(x,x,octet1,x);
ShiftOut(x,x,octet2,x);
ShiftOut(x,x,octet3,x);
ShiftOut(x,x,octet4,x);

C'est toi qui décide ce que tu mets dans les octets.
C'est toi qui décide si les deux premiers octets envoyés seront pour la température ou pour l'humidité.

Moilion

Un grand merci

Code: [Select]

#include "DHT.h"

#define DHTPIN 2     // what pin we're connected to


#define DHTTYPE DHT11   // DHT 11


DHT dht(DHTPIN, DHTTYPE);


/*
  Driving multiple 7-seg displays with 74HC595 shift registers.
 
  Feel free to re-use.
 
   01/30/2010
*/

const int  latchPin = 6;
const int  clockPin     = 7;
const int  dataPin    = 5;

// Definitions of the 7-bit values for displaying digits
byte chiffre[10];

// Current number being displayed
int nombreaaffiche = 0;
int nombreaaffichehum = 0;

// Number of shift registers in use
const int g_registerstemp = 2;

// Array of numbers to pass to shift registers
byte g_registerArraytemp [g_registerstemp];




void setup() {
  Serial.begin(9600);
  Serial.println("DHTxx test!");

  dht.begin();
 
  pinMode (latchPin, OUTPUT);
  pinMode (clockPin, OUTPUT);
  pinMode (dataPin, OUTPUT);
 
 
 
  // Setup the digits array
  // a = 8 b = 4 c = 2 d = 64 e = 32 f = 1 g = 16
  chiffre [0] = 8 + 4 + 2 + 64 + 32 + 1;
  chiffre [1] = 4 + 2;
  chiffre [2] = 8 + 4 + 16 + 32 + 64;
  chiffre [3] = 8 + 4 + 16 + 2 + 64;
  chiffre [4] = 1 + 16 + 4 + 2;
  chiffre [5] = 8 + 1 + 16 + 2 + 64;
  chiffre [6] = 8 + 1 + 16 + 2 + 64 + 32;
  chiffre [7] = 8 + 4 + 2;
  chiffre [8] = 8 + 4 + 2 + 64 + 32 + 1 + 16;
  chiffre [9] = 8 + 4 + 2 + 1 + 16 + 64;
} // setup

// Simple function to send serial data to one or more shift registers by iterating backwards through an array.
// Although g_registers exists, they may not all be being used, hence the input parameter.
void sendSerialData (
  byte registerCount,  // How many shift registers?
  byte *pValueArray)   // Array of bytes with LSByte in array [0]
{
  // Signal to the 595s to listen for data
  digitalWrite (latchPin, LOW);
 
  for (byte reg = registerCount; reg > 0; reg--)
  {
    byte value = pValueArray [reg - 1];
   
    for (byte bitMask = 128; bitMask > 0; bitMask >>= 1)
    {
      digitalWrite (clockPin, LOW);
   
      digitalWrite (dataPin, value & bitMask ? HIGH : LOW);
       
      digitalWrite (clockPin, HIGH);
    }
  }
  // Signal to the 595s that I'm done sending
  digitalWrite (latchPin, HIGH);
}  // sendSerialData







void loop() {
  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  // check if returns are valid, if they are NaN (not a number) then something went wrong!
  if (isnan(t) || isnan(h)) {
    Serial.println("Failed to read from DHT");
  } else {
    Serial.print("Humidity: ");
    Serial.print(h);
    Serial.print(" %\t");
    Serial.print("Temperature: ");
    Serial.print(t);
    Serial.println(" *C");
  }
 
 
  {
  nombreaaffiche = dht.readTemperature();
 
  if (nombreaaffiche < 10)
  {
    g_registerArraytemp [1] = chiffre [0];
    g_registerArraytemp [0] = chiffre [nombreaaffiche];
  }
  else if (nombreaaffiche < 100)
  {

    g_registerArraytemp [1] = chiffre [nombreaaffiche / 10];
    g_registerArraytemp [0] = chiffre [nombreaaffiche % 10];
  }
 

  sendSerialData (g_registerstemp, g_registerArraytemp);
}
{
  nombreaaffichehum =  dht.readHumidity();
 
  if (nombreaaffichehum < 10)
  {
    g_registerArraytemp [2] = chiffre [0];
    g_registerArraytemp [3] = chiffre [nombreaaffichehum];
  }
  else if (nombreaaffichehum < 100)
  {

    g_registerArraytemp [2] = chiffre [nombreaaffichehum / 10];
    g_registerArraytemp [3] = chiffre [nombreaaffichehum % 10];
  }
 

  sendSerialData (g_registerstemp, g_registerArraytemp);
}
}


XD

Moilion

Je reviens à vous, on sait jamais ça peut servir aux débutants en galère (comme moi  :smiley-sweat:)

J'avais des afficheurs à segments cathode commune et des afficheurs à segments anode commune.

Donc j'ai du modifié le code et ça fonctionne..

Code: [Select]

#include "DHT.h"

#define DHTPIN 2     // what pin we're connected to


#define DHTTYPE DHT11   // DHT 11


DHT dht(DHTPIN, DHTTYPE);


/*
  Driving multiple 7-seg displays with 74HC595 shift registers.
 
  Feel free to re-use.
 
   01/30/2010
*/

const int  latchPin = 6;
const int  clockPin     = 7;
const int  dataPin    = 5;

// Definitions of the 7-bit values for displaying digits
byte chiffre [9];
byte chiffrea [9];

// Current number being displayed
int nombreaaffiche = 0;
int nombreaaffichehum = 0;

// Number of shift registers in use
const int g_registerstemp = 4;

// Array of numbers to pass to shift registers
byte g_registerArraytemp [g_registerstemp];




void setup() {
  Serial.begin(9600);
  Serial.println("DHTxx test!");

  dht.begin();
 
  pinMode (latchPin, OUTPUT);
  pinMode (clockPin, OUTPUT);
  pinMode (dataPin, OUTPUT);
 
 
 
  // Setup the digits array
 
  //cathode commune (sortie commune gnd)
  // a = 8 b = 4 c = 2 d = 64 e = 32 f = 1 g = 16
  chiffre [0] = 8 + 4 + 2 + 64 + 32 + 1;
  chiffre [1] = 4 + 2;
  chiffre [2] = 8 + 4 + 16 + 32 + 64;
  chiffre [3] = 8 + 4 + 16 + 2 + 64;
  chiffre [4] = 1 + 16 + 4 + 2;
  chiffre [5] = 8 + 1 + 16 + 2 + 64;
  chiffre [6] = 8 + 1 + 16 + 2 + 64 + 32;
  chiffre [7] = 8 + 4 + 2;
  chiffre [8] = 8 + 4 + 2 + 64 + 32 + 1 + 16;
  chiffre [9] = 8 + 4 + 2 + 1 + 16 + 64;
  //anode commune (sortie commune 5v)
  chiffrea [0] = 16;
  chiffrea [1] = 8 + 64 + 32 + 16+ 1;
  chiffrea [2] = 1 + 2;
  chiffrea [3] = 32 + 1;
  chiffrea [4] = 8 + 64 + 32 ;
  chiffrea [5] = 32 + 4 ;
  chiffrea [6] =  4 ;
  chiffrea [7] =  64 + 32 + 16 + 1 ;
  chiffrea [8] =  0;
  chiffrea [9] = 32 ;
 
 
} // setup

// Simple function to send serial data to one or more shift registers by iterating backwards through an array.
// Although g_registers exists, they may not all be being used, hence the input parameter.
void sendSerialData (
  byte registerCount,  // How many shift registers?
  byte *pValueArray)   // Array of bytes with LSByte in array [0]
{
  // Signal to the 595s to listen for data
  digitalWrite (latchPin, LOW);
 
  for (byte reg = registerCount; reg > 0; reg--)
  {
    byte value = pValueArray [reg - 1];
   
    for (byte bitMask = 128; bitMask > 0; bitMask >>= 1)
    {
      digitalWrite (clockPin, LOW);
   
      digitalWrite (dataPin, value & bitMask ? HIGH : LOW);
       
      digitalWrite (clockPin, HIGH);
    }
  }
  // Signal to the 595s that I'm done sending
  digitalWrite (latchPin, HIGH);
}  // sendSerialData







void loop() {
  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  // check if returns are valid, if they are NaN (not a number) then something went wrong!
  if (isnan(t) || isnan(h)) {
    Serial.println("Failed to read from DHT");
  } else {
    Serial.print("Humidity: ");
    Serial.print(h);
    Serial.print(" %\t");
    Serial.print("Temperature: ");
    Serial.print(t);
    Serial.println(" *C");
  }
 
 
  {
  nombreaaffiche = dht.readTemperature();
 
  if (nombreaaffiche < 10)
  {
    g_registerArraytemp [1] = chiffre [0];
    g_registerArraytemp [0] = chiffre [nombreaaffiche];
  }
  else if (nombreaaffiche < 100)
  {

    g_registerArraytemp [1] = chiffre [nombreaaffiche / 10];
    g_registerArraytemp [0] = chiffre [nombreaaffiche % 10];
  }
 

  sendSerialData (g_registerstemp, g_registerArraytemp);
}
{
  nombreaaffichehum =  dht.readHumidity();
 
  if (nombreaaffichehum < 10)
  {
    g_registerArraytemp [3] = chiffrea [0];
    g_registerArraytemp [2] = chiffrea [nombreaaffichehum];
  }
  else if (nombreaaffichehum < 100)
  {

    g_registerArraytemp [3] = chiffrea [nombreaaffichehum / 10];
    g_registerArraytemp [2] = chiffrea [nombreaaffichehum % 10];
  }
 

  sendSerialData (g_registerstemp, g_registerArraytemp);
}
}

et encore un grand merci à vous  ;)

skizoh


Gatizne

Salut !

Je souhaiterais m'inspirer de ton système mais j'ai qq petites questions :

- est il possible d'afficher 3 t° et 3 valeurs d'humidité ? C'est à dire d'utiliser 8 modules de 4 afficheur 7 segments avec un seul arduino ? Sachant que je dois également piloter une carte 24 relais ?
Merci de vos lumières....

Go Up