====== Afficheur 7 segments à LED ======

//Necessary knowledge: [HW] [[en:hardware:homelab:digi]], [LIB] [[en:software:homelab:library:delay]], [LIB] [[en:software:homelab:library:module:segment_display]], [PRT] [[en:examples:digi:led]]//

//Connaissances nécessaires: [HW] [[fr:hardware:homelab:digi]], [LIB] [[fr:software:homelab:library:delay]], [LIB] [[fr:software:homelab:library:module:segment_display]], [PRT] [[fr:examples:digi:led]]//

===== Théorie =====

L'indicateur de nombres à 7 segments de LED est un afficheur qui est constitué de 7 LEDs positionnés en forme du chiffre 8. En allumant ou éteignant les LEDs correspondantes, i est possible d'afficher les chiffres de 0 à 9 ainsi qu'un bon nombre de lettres.

[{{  :examples:display:segment_display:segment_display_leds.png?300|Positionnement des segments de l'indicateur de LED et schéma électrique}}]

Electriquement toutes les anodes des LEDs sont connectées à la broche de l'anode //ca//. Les LEDs s'allument en inversant la position de leur cathode (//a, b, c...//). Il existe aussi des connections inversées, où les indicateurs ont une cathode commune //cc//. Habituellement la plupart des indicateurs de nombres sont utilisés pour afficher des nombres multi numériques - pour ce faire les indicateurs sont équipés d'un segment point //dp//. En tout et pour tout un indicateur est composé de 8 segments, mais il continu d'être appelé afficheur à 7 segments en accord avec le nombre de segments.

L'afficheur de nombre à LED est très facile à utiliser, il peut être contrôlé directement à partir des broches du micro-contrôleur, mais il existe des drivers spéciaux qui sont capable de contrôler l'afficheur en utilisant moins de broches du micro-contrôleur. Il existe différentes couleurs d'afficheurs qui peuvent être très brillantes et très larges. Enfin, il existe des afficheurs spécifiques composés de segments supplémentaires permettant d'afficher les caractères de l'alphabet Latin.

===== Pratique =====

Il y a un afficheur 7 segments disponible sur la carte du module numérique. Il est contrôlé par l'intermédiaire de l'interface en série A6275. L'interface en série est similaire à SPI, où on utilise les signaux de l'horloge et les signaux de donnée. Contrairement à SPI la fonction ''chip-select'' n'est pas utilisée ici, nous la remplacerons par la fonction ''latch''. Les trois voies mentionnées ci-dessus sont connectées à ATmega128 comme suit:   

[{{  :examples:display:segment_display:segment_display_driver_logic.png?300|La construction de l'index du driver de LED avec le segment de l'afficheur correspondant.}}]

  * Latch-signal (//latch//) - PG2
  * Clock-signal (//clock//) - PC7
  * Data-signal (//data//) - PC6

~~CL~~

Les données sont transmises en bits en passant par la broche de données. A chaque passage du signal de l'horloge en position haute, le contenu de l'index shift est modifié vers la droite et le bit provenant de la broche de données est lu vers la cellule la plus  à gauche. Avec ce 8 bits est transféré vers l'index shift. Si le signal //latch// est configuré en position haute, la valeur de l'index shift est transférée vers l'index latch, où il y rest jusqu'à un nouveau chargement. Chaque bits de l'index latch est connecté à l'interrupteur de courant de l'un des segments de l'afficheur. Le segment correspond est allumé en position haute du bit-rate.

Pour afficher des nombres sur l'afficheur du HomeLab, la fonctions suivante se trouve dans la librairie du HomeLab.

<code c>
//
// Set-up of the pins
//
static pin segment_display_latch =    PIN(G, 2);
static pin segment_display_data_out = PIN(C, 6);
static pin segment_display_clock =    PIN(C, 7);

//
// Marking card.
// The bits are marking the segments. Lower ranking is A, higher ranking is DP.
//
static const unsigned char segment_char_map[11] = 
{
	0b00111111,
	0b00000110,
	0b01011011,
	0b01001111,
	0b01100110,
	0b01101101,
	0b01111100,
	0b00000111,
	0b01111111,
	0b01100111,
	0b01111001   // E like Error
};
 
//
// Start-up of the 7-segment indicator.
//
void segment_display_init(void)
{
	// Set latch, data out and clock pins as output
	pin_setup_output(segment_display_latch);
	pin_setup_output(segment_display_data_out);
	pin_setup_output(segment_display_clock);
}
 
//
// Displaying number on the 7-segment indicator.
//
void segment_display_write(unsigned char digit)
{
	unsigned char map;
	signed char i;
	 
	// Check-up of the number
	if (digit > 9)
	{
		digit = 10;
	}
	
	// Number as the card of the segments.
	map = segment_char_map[digit];
 
	// Latch-signal off
	pin_clear(segment_display_latch);
 
	// Sending he bits. Higher ranking goes first.
	for (i = 7; i >= 0; i--)
	{
		// Setting the pin according to the value of the bit of the card.
		pin_set_to(segment_display_data_out, bit_is_set(map, i));
 
		// The clock-signal as high for a moment.
		pin_set(segment_display_clock);
		_delay_us(1);
 
		// The clock-signal as low.
		pin_clear(segment_display_clock);
		_delay_us(1);
	}
 
	// Latch-signal on.
	pin_set(segment_display_latch);
}
</code>

Dans le but d'afficher les chiffres ainsi que la lettre "E", nous utiliserons une liste constante ''segment_char_map'', qui permet d'allumer tous les segments marqués d'un 1 et inversement d'éteindre ceux marqués par un 0. Les bits du plus grand au plus petit (de gauche à droite de la forme binaire) sont dénomé par les segments DP, G, F, E, D, C, B, A. L'interface de contrôle du driver est réalisée a l'aide du logiciel SPI, i.e. en utilisant un logiciel permettant de contrôler les broches de communication dans le programme. Les trois broches sont configurées en sorties avec la fonction ''segment_display_init''. Puis la fonction ''segment_display_write''permet l'affichage, qui trouve la carte des segments à partir de la liste et transmet bit à bit toutes les valeurs des segments. Le fréquence de l'horloge avec les temporisation est d'environ 500 kHz.

Le programme suivant est un exemple plus concret d'une utilisation de l'afficheur. Les fonctions utilisées correspondent à celles évoquées ci-dessus. Le programme permet de compter de 0 à 9 avec un intervalle d'environ 1 seconde. Un tel comptage peut être réalisé en prenant en module depuis un nombre plus grand.

<code c>
//
// The example program of the 7-segment LED indicator of the Home Lab's
// input-output module.
//
#include <homelab/module/segment_display.h>
#include <homelab/delay.h>

//
// Main program.
//
int main(void)
{
	int counter = 0;

	// Set-up of the 7-segment indicator.
	segment_display_init();

	// Endless loop.
	while (true)
	{
		// Displaying the ones values of the counter.
		segment_display_write(counter % 10);

		// Counting very long.
		counter++;

		// Delay for 1 second.
		sw_delay_ms(1000);
	}
}
</code>