Bonjour,
Décidément j'ai du mal avec les décodeurs 7 segment ^^'

Voila sur le datasheet il y a une table de vérité.
Mais à l'application cette table de vérité ce révelle fausse et j'en ai une autre,

0 : 0000
1 : 1000
2 : 0010
3 : 1010
4 : 0001
5 : 1001
6 : 0011
7 : 1011
8 : 0100
9 : 1100

C'est normal? cela peut-être du à un mauvais branchement ?

J'ai fait une simulation avec ISIS avec les même branchement que j'ai sur d'être bon vu que isis produit ce que j'attend mais les résultats réel ne sont pas bon...

Quelles sont les différences entre théorie et pratique ? l'affichage fait n'importe quoi, n'affiche rien ?

quand je veux afficher un 8 sa affiche un 4, enfaite je me retrouve avec une table de vérité modifié. Je vais faire un schéma du montage
je pense pourtant avoir fait les bon branchement... j'en ai 2 et les 2 sont sont pareil... même problème

Voila le schéma :

Peut-on voir un bout de ton code?
N'as-tu pas inversé les bit?
Au début j'ai eu quelques problème comme ceci et les bit n'était pas à leur place.

C'est sur quoi je pense, une inversion/mélange dans les bits A,B,C et D...

Voila le code, j'ai l'habitude de programmé et de me corrigé, personnellement je n'ai pas trouvé d'erreur. Merci de m'aider à régler ce problème.

const int bit_A0 = 2;
const int bit_A1 = 3;
const int bit_A2 = 4;
const int bit_A3 = 5;


void setup()
{
	pinMode(bit_A0, OUTPUT);
	pinMode(bit_A1, OUTPUT);
	pinMode(bit_A2, OUTPUT);
	pinMode(bit_A3, OUTPUT);
	
	
	digitalWrite(bit_A0, LOW);
	digitalWrite(bit_A1, LOW);
	digitalWrite(bit_A2, LOW);
	digitalWrite(bit_A3, HIGH);

}

void loop() 
{
	
}

Dans ton schéma tu utilise les sorties 1 à 4 et dans ton code les sorties 2 à 5.

EDIT : regarde bien dans la datasheet car les bits ne sont pas dans l'ordre.

Niveau des sortis c'est bon par contre niveau Bit pas bon. Je pense que je viens de trouvé l'erreur... je vous dis ça
Bon c'est bon sa marche par contre ce code, qui fait parti du tuto d'arduino page sur l'utilisation de plusieurs afficheur ne fait aps ce qui est montré dans la vidéo... mais affiche 0,1,3 puis 7 et s'éteint...

//définition des broches du décodeur 7 segments (vous pouvez changer les numéros si bon vous semble)
const int bit_A = 2;
const int bit_B = 4;
const int bit_C = 5;
const int bit_D = 3;

//définitions des broches des transistors pour chaque afficheur (dizaines et unités)
const int alim_dizaine = 12;
const int alim_unite = 13;

void setup()
{
	//Les broches sont toutes des sorties
	pinMode(bit_A, OUTPUT);
	pinMode(bit_B, OUTPUT);
	pinMode(bit_C, OUTPUT);
	pinMode(bit_D, OUTPUT);
	pinMode(alim_dizaine, OUTPUT);
	pinMode(alim_unite, OUTPUT);
	
	//Les broches sont toutes mises à l'état bas
	digitalWrite(bit_A, LOW);
	digitalWrite(bit_B, LOW);
	digitalWrite(bit_C, LOW);
	digitalWrite(bit_D, LOW);
	digitalWrite(alim_dizaine, LOW);
	digitalWrite(alim_unite, LOW);
}

void loop() //fonction principale
{
	for(char i = 0; i<100; i++) //boucle qui permet de compter de 0 à 99 (= 100 valeurs)
	{
		afficher_nombre(i); //appel de la fonction affichage avec envoi du nombre à afficher
	}
}

//fonction permettant d'afficher un nombre sur deux afficheurs
void afficher_nombre(char nombre)
{
	long temps; //variable utilisée pour savoir le temps écoulé...
	char unite = 0, dizaine = 0; //variable pour chaque afficheur

	if(nombre > 9) //si le nombre reçu dépasse 9
        {
		dizaine = nombre / 10; //on récupère les dizaines
        }

	unite = nombre - (dizaine*10); //on récupère les unités

	temps = millis(); //on récupère le temps courant

	// tant qu'on a pas affiché ce chiffre pendant au moins 500 millisecondes
        // permet donc de pouvoir lire le nombre affiché
	while((millis()-temps) < 500)
	{
		//on affiche le nombre

		//d'abord les dizaines pendant 10 ms
		digitalWrite(alim_dizaine, HIGH); /* le transistor de l'afficheur des dizaines est saturé,
                                                    donc l'afficheur est allumé */
		digitalWrite(alim_unite, LOW); // l'autre transistor est bloqué et l'afficheur éteint
		afficher(dizaine); //on appel la fonction qui permet d'afficher le chiffre dizaine
                delay(10);

		//puis les unités pendant 10 ms
                digitalWrite(alim_dizaine, LOW); //on éteint le transistor allumé
		digitalWrite(alim_unite, HIGH); //et on allume l'autre
		afficher(unite); //on appel la fonction qui permet d'afficher le chiffre unité
                delay(10);
	}
}

//fonction écrivant sur un seul afficheur
//on utilise le même principe que vu plus haut
void afficher(char chiffre)
{
	if(chiffre >= 8)
	{
		digitalWrite(bit_D, HIGH);
		chiffre = chiffre - 8;
	}
	if(chiffre >= 4)
	{
		digitalWrite(bit_C, HIGH);
		chiffre = chiffre - 4;
	}
	if(chiffre >= 2)
	{
		digitalWrite(bit_B, HIGH);
		chiffre = chiffre - 2;
	}
	if(chiffre >= 1)
	{
		digitalWrite(bit_A, HIGH);
		chiffre = chiffre - 1;
	}
}

//le code est terminé