Élimination du rebond d'un interrupteur

Necessary knowledge: [HW] User Interface Module, [AVR] Digital Inputs/Outputs, [LIB] Pins, [LIB] Delay, [PRT] Switch Connaissances nécessaires: [HW] digi, [AVR] Entrées/sorties numériques, [LIB] Broches, [LIB] delay, [PRT] Interrupteur

Rebonds des contacts d'un interrupteur

Comme il a déjà été mentionné dans l'introduction du chapitre sur les interrupteurs, il existe un phénomène de rebond ou de clignotement lorsqu'on utilise des interrupteurs mécaniques. Le problème est d'autant plus important lorsqu'on utilise des contacteurs en métal qui admettent une certaine élasticité. Au moment de la connexion ou de la déconnexion, les contacteurs peuvent rebondir et peuvent fausser le résultat de l'interruption. Le nombre et la durée des changements dépendent du type d'interruption, ils se réalisent le plus souvent en quelques millisecondes. Dans le cas de l'utilisation d'un interrupteur pour démarrer un matériel électrique, le rebond n'est pas considéré comme un gros problème. Cependant, s'il est utilisé pour contrôler un matériel, plusieurs interruptions pourraient être nuisibles pour le matériel.

Filtre RC d'un interrupteur

La principale méthode utilisée pour éviter le clignotement est de filtrer le rebond causé par les contacteurs. Le filtrage peut être réalisé électriquement ou par un programme. Pour filtrer électriquement, l'interrupteur doit être connecté à un filtre passe-bas - comme par exemple un filtre RC - qui lisse les changements de tension. Par conséquent, les broches du micro-contrôleur ne sont pas perturbées par des valeurs transitoires. Le filtre RC est présenté sur le schéma. Le filtrage par un programme est réalisé en estimant la valeur de la patte à laquelle est connectée l'interrupteur ; si la valeur est la même pendant un laps de temps prédéfini, on considère que la position est stable et n'est donc pas concerné par l'effet de clignotement. Cependant, pour chaque types de filtrage, un facteur de délai pour définir l'état doit être pris en compte.

Le filtrage électrique ne sera pas utilisé dans les interrupteurs du Home Lab car il ne permettrait pas d'exercer l'élimintation d'une mauvais interruption à l'aide d'un programme. L'exercice est en deux parties. Le but de la première partie est de montrer le rebond des des interrupteurs du module d'entrée - sortie numérique. Le programme suivant est utilisé pour cela ; chaque pression sur le bouton allume la LED suivante sur la ligne. Mal appuyer sur le bouton causerait le clignotement des LED plusieurs fois et on pourrait croire ainsi qu'elles s'allument aléatoirement.

//
// The Program for demonstrating switch bounce on digital input-output module of home lab.
//
#include <homelab/pin.h>
 
//
// Determining pins of LED-s and buttons.
//
pin leds[3] = { PIN(C, 5), PIN(C, 4), PIN(C, 3) };
pin button  = PIN(C, 0);
 
//
// Main program
//
int main(void)
{
	unsigned char new_value, old_value = 0;
	unsigned char index, counter = 0;
 
	// Setting LED pins as output.
	for (index = 0; index < 3; index++)
	{
		pin_setup_output(leds[index]);		
	}
 
	// Setting button'spins as input.
	pin_setup_input(button);
 
	// Endless loop
	while (true)
	{
		// Reading the state of the button.
		new_value = pin_get_value(button);
 
		// Control, wether the button is pushed down,
		// that means is the new state 1 and old 0.
		if ((new_value) && (!old_value))
		{
			// Enlarging the reader and taking module 3
			counter = (counter + 1) % 3;
 
			// Lighting LED witch corresponds to the value of the reader.
			for (index = 0; index < 3; index++)
			{
				pin_set_to(leds[index], index != counter);
			}
		}
 
		// Remember the old state.
		old_value = new_value;
	}
}

Plusieurs solutions logiciels sont utiliser pour filtrer, tout cela peut être réalisé à la fois simplement ou de manière compliquée avec ses avantages et inconvénients. Si le programme est configuré pour n'avoir que quelques appuis peu fréquents sur le bouton, une longue pause peut être réalisée à la suite d'un appui, cela empêchera la réaction, a tort, de l'interrupteur a cause d'un rebond. Cependant, en utilisant cette méthode on doit considérer - au cas où l'utilisateur garde le bouton appuyé pendant un long moment, le programme va réagir a cause du relâchement du bouton. Un programme qui contrôle l'état de l'interrupteur de nombreuses fois dans une période fixe est plus conseillée (plus la durée est longue et plus le nombre de contrôles réalisés est important, plus le résultat est meilleur). La fonction ci-dessous permet de lire les valeurs filtrées d'un bouton pour le module d'entrée - sorties numérique :

//
// Function for reading filtered values of a IO extension module.
//
unsigned char pin_get_debounced_value(pin button)
{
	unsigned char buffer = 0xAA;	
	unsigned char timeout = 100;
 
	// We wait until the status of the button is celar or clearing the state expires
	while (timeout-- > 0)
	{
		// Having 8 place (bit) bufffer of state.
		// All previous states (bits) are shifted to left
		// and a new state(bit) is added to the right.
		buffer <<= 1;
		buffer |= (pin_get_value(button) ? 0x01 : 0x00);
 
		// If all 8 bits are high, then the button is definitely pressed down
		if (buffer == 0xFF)
		{
			return 1;
		}
 
		// If all 8 bits are low, then the button is definitely up.
		if (buffer == 0x00)
		{
			return 0;
		}
 
		// 1 ms break.
		// This function can be found from the library of the home lab.
		sw_delay_ms(1);
	}
 
	// If we can not examine the state, then we assume that the button was not pressed.
	return 0;
}

Cette fonction génère un délai en utilisant une fonction qui est expliquée dans l'exercice correspondant. Pour le moment, tout ce que nous devons connaître à propos de la fonction délai est qu'elle génère un délai de 1ms à la fin de chaque cycle afin de lire l'état du bouton. Si le bouton est dans le même état pendant 8 lectures, il renvoie la position comptée. Dans le cas d'un bouton instable, la procédure entière prendra 100ms. Cette fonction est incluse directement dans la bibliothèque qui concerne les barrettes, il n'est donc pas nécessaire de l'ajouter dans le programme au cours de cet exemple. Afin de pouvoir essayer cette première partie d'exercice, il doit être légèrement altéré - inclure la bibliothèque pour générer le délai dans le programme et à l'endroit où la valeur du bouton était lue, appliqer directement la fonction avec le filtre. Le résultat est le suivant :

//
// The program for filtering the debounch of buttons of digital input-output 
// module of the home lab.
//
#include <homelab/delay.h>
#include <homelab/pin.h>
 
//
// Determining pins of LED-s and buttons.
//
pin leds[3] = { PIN(C, 5), PIN(C, 4), PIN(C, 3) };
pin button  = PIN(C, 0);
 
//
// Main program
//
int main(void)
{
	unsigned char new_value, old_value = 0;
	unsigned char index, counter = 0;
 
	// Setting the pins of LED-s as outputs.
	for (index = 0; index < 3; index++)
	{
		pin_setup_output(leds[index]);		
	}
 
	// Setting the pins of button as input.
	pin_setup_input(button);
 
	// Endless loop.
	while (true)
	{
		// Reading the state of the button.
		new_value = pin_get_debounced_value(button);		
 
		// Control whether the button was pressed down, that means, 
		// is the new state 1 and the old state 0.
		if ((!new_value) && (old_value))
		{
			// Widening the counter and taking module number 3.
			counter = (counter + 1) % 3;
 
			// Lighting the LED witch corresponds to the value of the counter.
			for (index = 0; index < 3; index++)
			{
				pin_set_to(leds[index], index != counter);
			}
		}
 
		// Remember the old state.
		old_value = new_value;
	}
}

En testant ce nouveau programme, les LEDs s'allument exactement selon la séquence d'appui sur les boutons par l'utilisateur.