Incrémentation affichage digit 7 segment

Bonsoir, désolé d'ouvrir un topic uniquement pour ça, mais je ne trouve pas ma réponse sur le net...

J'ai récupérer un afficheur 7 segments sur une imprimante HP, et je n'ai aucune référence (ou elle ne retourne rien !)

Il à donc 11 pattes, répartie en 4 groupes comme suit : 11.10.9 /// 8.7 pour le coté gauche afficheur en face 6.5.4.3 /// 2.1 pour le coté droit afficheur en face

J'ai donc essayé en branchant un 5v sur une broche, puis de tester les broches une part une (avec une résistance de 330 Ohm) Ça me donne ça :

Il ne ce passe rien sur les broches 9, 8 et 5, a quoi servent-elles ? Je tient a préciser qu'il fonctionne très bien si je les branches tous en même temps !

Salut l'ours!

Certains afficheurs ont un ou deux DP (points pour faire des virgules devant ou derrière le digit).

Aucun DP, ici, y a pas une histoire d'anode commune ? J'ai fait des tests il affiche tout sans problème :) de 0 à 9

Bizounours: et je n'ai aucune référence (ou elle ne retourne rien !)

Sur l'afficheur il n'y a aucune référence? Les pattes sont peut être là uniquement pour des raisons mécaniques mais ne sont connectées à rien (NC).

Bizounours: ... y a pas une histoire d'anode commune ?

bonjour c'est le cas l'anode commune est sur ton pin1

Okay, de toute façon si tout fonctionne je risque pas de l'abîmer en oubliant des trucs ?

Bizounours: Okay, de toute façon si tout fonctionne je risque pas de l'abîmer en oubliant des trucs ?

non pas de problemes attention neanmoins pour utilisation , à bien mettre une resistance par segment si pour test de balayage on peut se contenter d'une seule , en utilisation il ne faut pas le faire le courant/lumunisoté serait affecté par le nombre de segments sollicités.

Bonjour,

comme tu peux le voir ici : http://www.datasheetarchive.com/dlmain/Datasheets-X2/DSA879000-47.pdf il y a des pins qui sont juste mit comme ça, pour le fun. :grin:

Ha bah tout va bien alors, je vais essayer de me faire un petit module, ça m'évitera des montages / démontages fastidieux !

Bon bah voilà, j’ai terminer mon module, le devant ça va, mais le dos… Vous avez des astuces pour faire des trucs plus propres ? :grin:

ça va, j’ai vu pire. Pour moi c’est propre.

Du moment que ça tient, c'est tout bon!

J'y mettrais une petite couche de colle à chaud pour tenir et isoler le tout, en prenant de la bien opaque, ça fait en plus cache-misère! ;)

Ha bah ça va alors, j'essaierais de faire un coffrage de colle XD Y a plus qu'à essayer de faire une librairie pour faciliter le code parce que bonjour le volume d'instruction :sweat_smile:

http://playground.arduino.cc/Main/SevenSegmentLibrary

Merci bien :D

Du coup, je m’amuse pas mal avec ce petit afficheur, et j’aimerais en faire un compteur :grin:
Le but serait de partir de 0, et d’augmenter disons jusqu’à 20, puis clignotement de l’afficheur sur 0 deux ou trois seconde et repartir en comptage.

En gros a partir des 10ènes je pensais affiché rapidement 1 puis 0, puis une petit pause, puis 1 puis 0 ect jusqu’à la nouvelle incrémentation.

Le problème c’est que je manque de base pour incrémenter l’affichage du digit via une coupure !

Voilà mon code actuel, la détection ce passe extrêmement bien et surtout très réactif !

// Définition des pin du digit
const int A = 2;
const int B = 3;
const int C = 4;
const int D = 5;
const int E = 6;
const int F = 7;
const int G = 8;

int capteur1 = A0;
int lum1 = 0;

void setup() 
{ 
  pinMode(A, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(C, OUTPUT);
  pinMode(D, OUTPUT);
  pinMode(E, OUTPUT);
  pinMode(F, OUTPUT);
  pinMode(G, OUTPUT);
}

void loop() 
{
  lum1 = analogRead(capteur1);
  
  if (lum1 < 999) // LDR calibré pour lumière de ma chambre (<999) et lumière du laser (>= 1000)
    {
     digitalWrite(A, LOW);   
     digitalWrite(B, LOW);   
     digitalWrite(C, LOW);   
     digitalWrite(D, LOW);   
     digitalWrite(E, LOW);   
     digitalWrite(F, LOW);   
     digitalWrite(G, HIGH);
    }
  
  else
    {
    digitalWrite(A, HIGH);   
    digitalWrite(B, LOW);   
    digitalWrite(C, LOW);   
    digitalWrite(D, HIGH);   
    digitalWrite(E, HIGH);   
    digitalWrite(F, HIGH);   
    digitalWrite(G, HIGH);
    }
    
  delay(1);  
}

déjà, coller ce code (faut le finir), ça te fait une fonction unique que tu appelleras selon tes besoins, genre "affiche(7);"

void affiche(byte val){  // affiche le chiffre val
  switch (val){
    case 0 :
     digitalWrite(A, LOW);   
     digitalWrite(B, LOW);   
     digitalWrite(C, LOW);   
     digitalWrite(D, LOW);   
     digitalWrite(E, LOW);   
     digitalWrite(F, LOW);   
     digitalWrite(G, HIGH);
     break;
    case 1 :
     digitalWrite(A, HIGH);   
     digitalWrite(B, LOW);   
     digitalWrite(C, LOW);   
     digitalWrite(D, HIGH);   
     digitalWrite(E, HIGH);   
     digitalWrite(F, HIGH);   
     digitalWrite(G, HIGH);
     break;
// etc etc...
    default :
     digitalWrite(A, HIGH);   
     digitalWrite(B, HIGH);   
     digitalWrite(C, HIGH);   
     digitalWrite(D, HIGH);   
     digitalWrite(E, HIGH);   
     digitalWrite(F, HIGH);   
     digitalWrite(G, HIGH);
     break;
  }
}

Ca marche nickel, c’est pratique, on peu pas en faire une librairie ?
Genre #include <Digit.h>

Après j’ai plus qu’à faire :
affiche(x);

Sinon j’ai beau chercher, je ne vois pas comment lui faire comprendre qu’il faille rester sur le chiffre actuel ?

Si je fait une boucle il reviendra sans cesse sur l’état précédent…
En fait il faudra un if while (Si le laser et coupé, et tant qu’il l’est, affiche l’état précédent, sinon, affiche++) :grin:

Bizounours:
Du coup, je m’amuse pas mal avec ce petit afficheur, et j’aimerais en faire un compteur :grin:
Le but serait de partir de 0, et d’augmenter disons jusqu’à 20, puis clignotement de l’afficheur sur 0 deux ou trois seconde et repartir en comptage.

Bonsoir,
voici j’ai fait un code juste pour toi (qui fait exactement ce que tu dis). Mais il faut avant tout que tu comprennes le principe du multiplexage car ici on n’utilise que des transistors pour la commutation (persistance rétinienne) et pas de décodeur.
Le code ci-dessous fait clignoté le 0 pendant 2 secondes et commence ensuite le comptage jusqu’à 20. Arriver à 20, on a un retour à zéro puis clignotement à nouveau des zéro.
Il ne te reste plus qu’à brancher les afficheurs comme il se doit et de contempler le résultat. :grin:

byte digit0 = 10; // broche du 1er transistor
byte digit1 = 11;  // broche du 2ème transistor

int count, count1, count2, a, b = 0;

long lastTime, millisTime, deltaTime = 0;

byte sevenSegmentPins[] = {2,3,4,5,6,7,8}; /*Broches à utiliser par l'afficheur déclarer sous forme de tableau ce qui est très pratique je dirai*/

byte sevenSegment[10][7] =
{
//a b c d e f g
{ 0,0,0,0,0,0,1 }, // = 0
{ 1,0,0,1,1,1,1 }, // = 1
{ 0,0,1,0,0,1,0 }, // = 2
{ 0,0,0,0,1,1,0 }, // = 3
{ 1,0,0,1,1,0,0 }, // = 4
{ 0,1,0,0,1,0,0 }, // = 5
{ 0,1,0,0,0,0,0 }, // = 6
{ 0,0,0,1,1,1,1 }, // = 7
{ 0,0,0,0,0,0,0 }, // = 8
{ 0,0,0,1,1,0,0 } // = 9
};  // Ceci est la base même du multiplexage

void setup()
{
pinMode(digit0, OUTPUT); //pin 10
pinMode(digit1, OUTPUT); //pin 11

// Configuration en sortie des broches pour les afficheurs.
for(int i=0; i<7; i++) {
pinMode(sevenSegmentPins[i], OUTPUT);
}
}

//fonction pour écrire le nombre sur l'afficheur
void segmentWrite(byte digit)
{
byte pin = 2;
for (byte i=0; i<7; i++) {
digitalWrite(pin, sevenSegment[digit][i]);
++pin;
}
}

void loop()
{
// Au départ count est = 0
//On sépare le nombre en deux partie pour pouvoir les envoyer ensuite sur chaque afficheur.
a = count % 10; // Obtenir le modulo nombre
count1 = int (a); //convertir le nombre en une variable intéger
b = count / 10; //diviser le nombre par 10
count2 = int (b); //convertir le nombre en une variable intéger 

if (count == 0)
{
int t=0;
while(t<3){
  digitalWrite(digit1, HIGH);
  digitalWrite(digit0, HIGH);
  segmentWrite(count2);
  segmentWrite(count1);
  delay(1000);
  digitalWrite(digit1, LOW);
  digitalWrite(digit0, LOW);
  delay(1000);  
  t++;
  
} 
}

else if(count>0 && count <=20) // technique de multiplexage
{
digitalWrite(digit1, LOW);
segmentWrite(count2);
delay(10);
digitalWrite(digit1, HIGH);
digitalWrite(digit0, LOW);
segmentWrite(count1);
delay(10);
digitalWrite(digit0, HIGH);
}
// On incrémente "count" toutes les une seconde
millisTime = millis();
deltaTime = millisTime-lastTime;
if (deltaTime>1000)
{
count++;
lastTime = millisTime;
}
// Remettre "count" à 0 si count est supérieur à 20
if(count > 20)
count = 0;
}

Au cas où tu ne le saurais pas, pour le branchement des afficheurs tu dois les mettre en parallèle c’est à dire :

A → A’
B → B’
C → C’


G → G’

Pour les transistors (2 en tout, un par afficheur. type BC549 ou 547), tu mettras un résistance de 4,7K sur chaque Base. Les émetteurs sont relié à 5V puis les collecteurs à chaque anode commune de chaque afficheur (dans le cas d’un afficheur à anode commune).

Bonjour merci beaucoup pour le code, ça me servira plus tard :) Pour le moment je n'utilise qu'un digit et Super_Cinci a déjà proposer de quoi bien raccourcir les lignes XD Le vrai problème maintenant c'est de réagir a la coupure du laser, et pour être plus précis, vu que c'est du comptage, il faut que l'incrementation ce fasse non pas a la coupure du laser, mais au rétablissement de la liaison, ce qui assurera que l'objet soit bien passer a travers !