Débuter en électronique !

[Artemus24]

Salut à tous.

Désolé pour ma réponse tardive, mais je n'étais pas trop disponible ces derniers jours.

@ Bud Spencer : oui, pourquoi pas car après tout, je ne connais pas node.js.

@ destroyedlolo : oui, j'ai vraiment envie de jouer avec les threads, mais aussi de comprendre comment fonctionne le GPIO.
Voici le programme écrit en 'C' qui permet de gérer trois timer :

Code : Tout sélectionner

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>

#define sigev_notify_function		_sigev_un._sigev_thread._function
#define sigev_notify_attributes		_sigev_un._sigev_thread._attribute
#define sigev_notify_thread_id		_sigev_un._tid

#define _PERIOD_SIG			SIGRTMIN
#define _PERIOD_SEC			0
#define _PERIOD_NSEC			100000000 /* 100ms */

#define _NBRE				3

/******************************/
/*                            */
/*     Variables Globales     */
/*                            */
/******************************/

pthread_cond_t		cond;
pthread_mutex_t		mutex;

/*================================*/
/*     Passage des paramètres     */
/*================================*/

typedef struct
{
	pthread_t	iThread;
	int		iNumero;
	void		*function;
	int		period_sec;
	int		period_nsec;
} PARAMS, *LPARAMS;

PARAMS			params[3] =
{{0, 1, 0, _PERIOD_SEC, _PERIOD_NSEC},
 {0, 2, 0, _PERIOD_SEC, _PERIOD_NSEC},
 {0, 3, 0, _PERIOD_SEC, _PERIOD_NSEC}};

int	flag;

/********************************/
/*                              */
/*     Création des Threads     */
/*                              */
/********************************/

void button1(union sigval arg)
{
	static int i = 0;

	pthread_mutex_lock(&mutex);

	printf("Button 1 : %d\n", ++i);

	if (i>=10)
		flag=1;

	/*=====================================*/
	/*     Condition d'arrêt du Thread     */
	/*=====================================*/

	if (flag)
		pthread_cond_signal(&cond);

	pthread_mutex_unlock(&mutex);
	pthread_exit(NULL);
}

void button2(union sigval arg)
{
	static int i = 0;

	pthread_mutex_lock(&mutex);

	printf("\t\tButton 2 : %d\n", ++i);

	/*=====================================*/
	/*     Condition d'arrêt du Thread     */
	/*=====================================*/

	if (flag)
		pthread_cond_signal(&cond);

	pthread_mutex_unlock(&mutex);
	pthread_exit(NULL);
}

void led(union sigval arg)
{
	static int i = 0;

	pthread_mutex_lock(&mutex);

	printf("\t\t\t\tLed : %d\n", ++i);

	/*=====================================*/
	/*     Condition d'arrêt du Thread     */
	/*=====================================*/

	if (flag)
		pthread_cond_signal(&cond);

	pthread_mutex_unlock(&mutex);
	pthread_exit(NULL);
}

/*******************************/
/*                             */
/*     Création des Timers     */
/*                             */
/*******************************/

void *timer(void *arg)
{
	int			status;
	timer_t			timerid;
	struct sigevent		sevt;
	struct itimerspec	its;

	/*======================*/
	/*     Verrouillage     */
	/*======================*/

	pthread_mutex_lock(&mutex);

	/*================================*/
	/*     Passage des paramètres     */
	/*================================*/

	LPARAMS	lparams = arg;

	/*===========================*/
	/*     Création du Timer     */
	/*===========================*/

	sevt.sigev_notify		= SIGEV_THREAD;
	sevt.sigev_notify_function	= lparams->function;
        sevt.sigev_notify_attributes    = NULL;
	sevt.sigev_value.sival_ptr	= &timerid;

	if ((status = timer_create(CLOCK_REALTIME, &sevt, &timerid)) == -1)
	{
		printf("%s : %d : timer %d create failed : %d\n", __FILE__, __LINE__, lparams->iNumero, status);
		pthread_exit(NULL);
	}

	/*============================*/
	/*     Lancement du Timer     */
	/*============================*/

	its.it_value.tv_sec     = lparams->period_sec;
	its.it_value.tv_nsec    = lparams->period_nsec;
	its.it_interval.tv_sec  = lparams->period_sec;
	its.it_interval.tv_nsec = lparams->period_nsec;

	if ((status = timer_settime(timerid, 0, &its, NULL)) == -1)
	{
		printf("%s : %d : timer %d settime start failed : %d\n", __FILE__, __LINE__, lparams->iNumero, status);
		pthread_exit(NULL);
	}

	/*=================================================*/
	/*      Condition d'attente de la fin du timer     */
	/*=================================================*/

	pthread_cond_wait(&cond, &mutex);

	/*========================*/
	/*     Arrêt du Timer     */
	/*========================*/

	its.it_value.tv_sec     = 0;
	its.it_value.tv_nsec    = 0L;
	its.it_interval.tv_sec  = 0;
	its.it_interval.tv_nsec = 0L;

	if ((status = timer_settime(timerid, 0, &its, NULL)) == -1)
	{
		printf("%s : %d : timer %d settime stop failed : %d\n", __FILE__, __LINE__, lparams->iNumero, status);
		pthread_exit(NULL);
	}

	/*==============================*/
	/*     Destruction du Timer     */
	/*==============================*/

	if ((status = timer_delete(timerid)) == -1)
	{
		printf("%s : %d : timer %d delete failed : %d\n", __FILE__, __LINE__, lparams->iNumero, status);
		pthread_exit(NULL);
	}

	/*=======================*/
	/*     Déverouillage     */
	/*=======================*/

	pthread_mutex_unlock(&mutex);

	pthread_exit(NULL);
}

/********************************/
/*                              */
/*     Procédure Principale     */
/*                              */
/********************************/

int main(int argc, char *argv[])
{
	int	i,status;

	/*========================*/
	/*     Initialisation     */
	/*========================*/

	flag=0;

	/*=============================*/
	/*     Création d'un mutex     */
	/*=============================*/

	if ((status = pthread_mutex_init(&mutex, NULL)))
	{
		printf("%s : %d : mutex init failed : %d\n", __FILE__, __LINE__, status);
		exit(0);
	}

	/*===========================================*/
	/*     Création d'une variable condition     */
	/*===========================================*/

	if ((status = pthread_cond_init(&cond, NULL)))
	{
		printf("%s : %d : condition variable init failed : %d\n", __FILE__, __LINE__, status);
		exit(0);
	}

	/*=======================================*/
	/*     Démarrage de tous les threads     */
	/*=======================================*/

	for (i=0; i<_NBRE; i++)
	{
		switch(i)
		{
			case 0: params[i].function = button1;
				break;

			case 1: params[i].function = button2;
				break;

			case 2: params[i].function = led;
				break;
		}

		if ((status = pthread_create(&params[i].iThread, NULL, timer, (void *) &params[i])))
		{
			printf("%s : %d : thread %4d create failed : %d\n", __FILE__, __LINE__, params[i].iNumero, status);
			exit(0);
		}
	}

	/*======================================================*/
	/*     Attente que tous les Threads soient terminés     */
	/*======================================================*/

	for (i=0; i<_NBRE; i++)
	{
		if ((status = pthread_join(params[i].iThread, NULL)))
		{
			printf("%s : %d : thread %4d join failed : %d\n", __FILE__, __LINE__, params[i].iNumero, status);
			exit(0);
		}
	}

	/*==============================================*/
	/*     Destruction de la variable condition     */
	/*==============================================*/

	if ((status = pthread_cond_destroy(&cond)))
	{
		printf("%s : %d : condition variable destroy failed : %d\n", __FILE__, __LINE__, status);
		exit(0);
	}

	/*==============================*/
	/*     Destruction du Mutex     */
	/*==============================*/

	if ((status = pthread_mutex_destroy(&mutex)))
	{
		printf("%s : %d : mutex destroy failed : %d\n", __FILE__, __LINE__, status);
		exit(0);
	}

	exit(0);
}

Et voici le résultat à l'affichage :

Code : Tout sélectionner

~/Prog_C/ex_04> timer
                Button 2 : 1
                                Led : 1
Button 1 : 1
Button 1 : 2
                                Led : 2
                Button 2 : 2
Button 1 : 3
                Button 2 : 3
                                Led : 3
Button 1 : 4
                                Led : 4
                Button 2 : 4
Button 1 : 5
                Button 2 : 5
                                Led : 5
Button 1 : 6
                Button 2 : 6
                                Led : 6
Button 1 : 7
                Button 2 : 7
                                Led : 7
Button 1 : 8
                                Led : 8
                Button 2 : 8
Button 1 : 9
                Button 2 : 9
                                Led : 9
                Button 2 : 10
Button 1 : 10
                                Led : 10
                                Led : 11
~/Prog_C/ex_04>

Je l'ai testé et il fait exactement ce pourquoi je l'ai écrit.
Je ne l'ai pas terminé car je n'ai pas encore introduit la partie consacré aux GPIO, que j'ai testé par ailleurs.
La tâche "Button 1" gère l'arrêt de tous les timers.
J'ai considéré que chaque timer était une seule file d'attente répétitive qu'il fallait géré séparément.
Et voici le programme 'C' où j'ai testé mon montage électronique :

Code : Tout sélectionner

#include <stdio.h>
#include <stdlib.h>
#include <bcm2835.h>

				/*-----------+--------*/
#define KEY	RPI_GPIO_P1_11	/* Broche 11 | GPIO17 */
#define LED_a	RPI_GPIO_P1_12	/* Broche 12 | GPIO18 */
#define LED_b	RPI_GPIO_P1_15	/* Broche 15 | GPIO22 */
#define LED_c	RPI_GPIO_P1_16	/* Broche 16 | GPIO23 */
#define LED_d	RPI_GPIO_P1_18	/* Broche 18 | GPIO24 */
#define LED_e	RPI_GPIO_P1_22	/* Broche 22 | GPIO25 */
#define LED_f	RPI_GPIO_P1_07	/* Broche  7 | GPIO04 */
#define LED_g	RPI_GPIO_P1_24	/* Broche 24 | GPIO08 */
				/*-----------+--------*/

void raz_leds(void)
{
	bcm2835_gpio_write(LED_a, LOW);
	bcm2835_gpio_write(LED_b, LOW);
	bcm2835_gpio_write(LED_c, LOW);
	bcm2835_gpio_write(LED_d, LOW);
	bcm2835_gpio_write(LED_e, LOW);
	bcm2835_gpio_write(LED_f, LOW);
	bcm2835_gpio_write(LED_g, LOW);
}

int main(void)
{
	int y, z, press, prev, rang;

	printf("Début: Bouton et Leds clignotantes\n");

	/*---------------------*/
	/* Initialisation GPIO */
	/*---------------------*/

	if (!bcm2835_init())	exit(-1);

	bcm2835_gpio_fsel(   KEY,   BCM2835_GPIO_FSEL_INPT);
	bcm2835_gpio_set_pud(KEY,   BCM2835_GPIO_PUD_DOWN);

	bcm2835_gpio_fsel(   LED_a, BCM2835_GPIO_FSEL_OUTP);
	bcm2835_gpio_fsel(   LED_b, BCM2835_GPIO_FSEL_OUTP);
	bcm2835_gpio_fsel(   LED_c, BCM2835_GPIO_FSEL_OUTP);
	bcm2835_gpio_fsel(   LED_d, BCM2835_GPIO_FSEL_OUTP);
	bcm2835_gpio_fsel(   LED_e, BCM2835_GPIO_FSEL_OUTP);
	bcm2835_gpio_fsel(   LED_f, BCM2835_GPIO_FSEL_OUTP);
	bcm2835_gpio_fsel(   LED_g, BCM2835_GPIO_FSEL_OUTP);

	/*-----------------*/
	/* Boucle Générale */
	/*-----------------*/

	prev = 0;

	for(y=0; y<5;)
	{
		while ((press = bcm2835_gpio_lev(KEY)) == prev)
			bcm2835_delay(100);

		prev = press;

		switch (press)
		{
			/*-----------------------------------------*/
			/* Bouton relaché : Remise à zéro des leds */
			/*-----------------------------------------*/

			case 0:
				printf("(%d) Bouton relaché\n\n", y+1);
				y++;
				raz_leds();
				break;

			/*----------------------------------*/
			/* Bouton pressé : effet chenillard */
			/*----------------------------------*/

			case 1:
				printf("(%d) Bouton Pressé\n", y+1);

				for (z=0, rang=0; z<49; z++, rang=z%7)
				{
					switch (rang)
					{
						case 0:
							bcm2835_gpio_write(LED_g, LOW);
							bcm2835_gpio_write(LED_a, HIGH);
							break;

						case 1:
							bcm2835_gpio_write(LED_a, LOW);
							bcm2835_gpio_write(LED_b, HIGH);
							break;

						case 2:
							bcm2835_gpio_write(LED_b, LOW);
							bcm2835_gpio_write(LED_c, HIGH);
							break;

						case 3:
							bcm2835_gpio_write(LED_c, LOW);
							bcm2835_gpio_write(LED_d, HIGH);
							break;

						case 4:
							bcm2835_gpio_write(LED_d, LOW);
							bcm2835_gpio_write(LED_e, HIGH);
							break;

						case 5:
							bcm2835_gpio_write(LED_e, LOW);
							bcm2835_gpio_write(LED_f, HIGH);
							break;

						case 6:
							bcm2835_gpio_write(LED_f, LOW);
							bcm2835_gpio_write(LED_g, HIGH);
							break;
					}
					bcm2835_delay (100);
				}
				break;
		}
	}

	/*-------------------*/
	/* Fin du Traitement */
	/*-------------------*/

	raz_leds();

	bcm2835_close();

	printf("Fin: Bouton et Leds clignotantes\n");

	exit(EXIT_SUCCESS);
}

@+

[Artemus24]

Salut à tous.

Qu'est-ce qu'il me reste à faire ? Deux choses :

*) terminer le montage électronique. Entre autre, coller sur la plaque de montage des câbles que je ne possède pas pour l'instant.
J'ai fait des tests à partir des jumpers du kit, en les reliant directement sur les GPIO de la raspberry. Pourquoi ?
Parce que je ne possède pas de jumpers mâle/mâle !

*) finir le programme 'C', en introduisant la partie consacré à la gestion des leds et des interrupteurs.
Entre autre, gérer le passage des paramètres entre les trois tâches.

Sinon, j'ai encore des questions sur les interrupteurs :

18) à ce paragraphe, pouvez-vous répondre, svp ?

19) au §18) j'ai parlé de mon choix pour configurer l'interrupteur en choisissant le montage de la figure 4d).
Je n'ai pas compris la différence avec les trois autres cas.

Comment en 'C', on gère cette différence de bouton enfoncé produisant un courant à 3,3 volts (figure 4d) ou un courant à 0 volt (figure 4c) ?
Il semble que cela se gère par le paramètre "bcm2835_gpio_set_pud(KEY, BCM2835_GPIO_PUD_DOWN);".
Or, j'ai testé en mettant "bcm2835_gpio_set_pud(KEY, BCM2835_GPIO_PUD_UP);", mais cela n'a rien changé.
Quand le bouton est enfoncé, j'obtiens un "1" et quand je le relache, j'obtiens un "0".
Cela n'aurait pas dû être l'inverse ?

@+

[Bud Spencer]

Déjà, Bravo. Pour une fois on a du vrai code et ça, ça change de ceux qui critiquent toujours tout sans jamais rien démontrer (donc très certainement sans savoir vraiment). S’il y avait un peu plus d’exemple de code comme le tient, ce serait beaucoup plus productif et on verrait peut etre plus d’utilisateur de PI faire autre chose que de l’utiliser uniquement pour du retro gaming ou du diffuseur de média.

Sinon, juste pour 2 boutons et une led, tu remarqueras qu’il t’a fallu ~150 ligne de code et créer 3 threads que tu dois surveiller en plus du thread principal. Une chance que tu te sois limité à un seul mutex commun, sinon tu aurais dut écrire un bouquin complet. Avec NodeJS, tu aurais fait la meme chose en 10 lignes et 5 minutes avec énormément d’avantages que tu n’auras jamais ici

Revenons à l’électronique :

Déjà, je vois que tu utilises la lib bcm2835. Excellent choix. C’est le moyen le plus rapide et le plus riche pour accéder a toutes les possibilités du gpio. Je l’utilise depuis la version 1.2 et après avoir tout essayé, je n’ai encore rien trouvé de mieu. Je l’utilise aussi bien en c, c++, c# mais aussi avec NodeJS notamment avec le wrapper rpio.

Pour ce qui est de ton problème de bouton, de 2 choses l’une:
Soit tu utilises une résistance externe comme sur tes dessin, soit tu utilises un pulldown ou un pullup.

Exemple avec le dessin 4D.
Si tu laisses la résistance de 4.7K, tu ne dois pas utiliser d’instruction de pull (ou alors avec l’enumérateur BCM2835_GPIO_PUD_OFF).

Si tu enlèves la résistance, il faut utiliser BCM2835_GPIO_PUD_DOWN. La gpio sera maintenue a un état bas par une résistance interne au soc. La valeur de la GPIO sera 0 par défaut et passera à 1 quand tu la relieras au 3.3v en appuyant sur le bouton.

Si tu veux utiliser BCM2835_GPIO_PUD_UP, il faut la aussi enlever la résistance mais il faut aussi relier l’autre pate du bouton non plus au 3.3v mais au gnd. Dans ce cas, la valeur de la GPIO sera à 1 par défaut et passera à 0 quand tu la mettras au gnd en appuyant sur le bouton. C’est la méthode conseillée. Elle permet de ne pas exposer de 3.3v non protégé sur circuit de ton bouton.

[destroyedlolo]

Oui, je vois que tu t'amuses bien
Je ne serai pas du tout parti sur un tout autre code, mais comme disait l'autre : "il y a autant de solution différente que de programmeurs pour les coder"

Pour les pull-up pull-down, ca fonctionne comme tu as pu le voir sur les ESP ou les arduino.
PULL-UP : remplace comme sont nom l'indique une résistance de tirage vers le +3.3v L'inter doit être mis vers la masse et appuyé, il enverra donc une tension 0.
PULL-DOWN : résistance de tirage vers la masse : L'inter doit donc etre relier au +3.3, il renvoie un 1 logique.

Sinon, comme je le disais, pour un exemple aussi simple, il est plus judicieux d'utiliser le kernel que la librairie BMC ... car les API du kernel fonctionneront quelque soit la machine (même sur un PC s'il a des GPIO ... ce qui est parfois le cas pour ses LED) et pas uniquement sur la Framboise.

[Artemus24]

Salut à tous.

Déjà, Bravo. Pour une fois on a du vrai code et ça, ça change de ceux qui critiquent toujours tout sans jamais rien démontrer (donc très certainement sans savoir vraiment). S’il y avait un peu plus d’exemple de code comme le tient, ce serait beaucoup plus productif et on verrait peut être plus d’utilisateur de PI faire autre chose que de l’utiliser uniquement pour du retro gaming ou du diffuseur de média.

C'est bien la première fois depuis que je fréquente les forums que l'on me fait autant de compliments.
Merci beaucoup, cela me va droit au cœur !!!

Sinon, juste pour 2 boutons et une led, tu remarqueras qu’il t’a fallu ~150 ligne de code et créer 3 threads que tu dois surveiller en plus du thread principal.

J'ai tendance à dire que le 'C/C++' est un langage bavard, tout comme le cobol d'ailleurs.
Ce n'est pas un problème en soi, enfin pas pour moi. Peut-être pour ceux qui aiment gagner du temps.

Comme je suis bavard aussi, on peut faire plus concis en supprimant tous les commentaires.

Une chance que tu te sois limité à un seul mutex commun, sinon tu aurais dut écrire un bouquin complet.

Un seul mutex est nécessaire afin que les traitements ne se chevauchent pas.
Une seule variable condition afin de bloquer la suite du traitement des timers.

Avec NodeJS, tu aurais fait la même chose en 10 lignes et 5 minutes avec énormément d’avantages que tu n’auras jamais ici

Sûrement, mais je ne connais pas suffisamment ce langage pour faire des prouesses.

Déjà, je vois que tu utilises la lib bcm2835. Excellent choix.

J'ai suivi ton conseil, et j'ai cherché sur le net comme l'utiliser au mieux.

Pour ce qui est de ton problème de bouton, ...

C'est juste un choix pour le câblage de l'interrupteur, en électronique, ainsi que sa gestion dans le programme 'C'.

Soit tu utilises une résistance externe comme sur tes dessin, soit tu utilises un pulldown ou un pullup.

Comme je n'y connais rien en électronique, je ne sais pas faire la différence entre les quatre solutions proposées.
Même après avoir relu l'article de framboise314, je ne saisie pas les différences ni les conséquences de ces choix.

Premier point : je cherche dans le programme 'C', la correspond entre 'ON' = '1' (bouton enfoncé) et 'OFF' = '0' (bouton relâché).
A moins de me tromper, je pense que ce choix est un pull-down (ou résistance de tirage).

Au niveau électronique, bouton enfoncé produit un courant = 3,3Vcc et bouton relâché produit un courant = 0,0Vcc (=ground).
Cela me parait logique comme façon de faire. Maintenant, je ne sais pas trop si cette solution est viable en électronique.

Deuxième point et non des moindre, la sécurité du GPIO.
Si par inadvertance, je déclare ce GPIO en OUTPUT au lieu de INPUT et que j'appuie sur le bouton, je crame la raspberry. Est-ce bien cela ?
D'où l'importance d'avoir une résistance de sécurité, qui n'est pas présente dans la figure 4d, ni dans les autres figures.

J'ai trouvé ce schéma qui correspond plus à ce que je désire faire :



Il manque la résistance de 100 ohms que je n'ai pas.

Si tu laisses la résistance de 4.7K, tu ne dois pas utiliser d’instruction de pull (ou alors avec l'énumérateur BCM2835_GPIO_PUD_OFF).

J'ai mis ceci dans le programme 'C' : "bcm2835_gpio_set_pud(KEY_a, BCM2835_GPIO_PUD_OFF);". Pareil pour la "KEY_b".

la valeur de la GPIO sera à 1 par défaut et passera à 0 quand tu la mettras au gnd en appuyant sur le bouton. C’est la méthode conseillée. Elle permet de ne pas exposer de 3.3v non protégé sur circuit de ton bouton.

Je me focalise peut-être trop sur 'ON' = '1' et 'OFF' = '0' pour le pull-down.
Mais en quoi le pull-up est la méthode conseillée, puisque le résultat est inversé : 'ON' = '0' et 'OFF' = '1' ?

La convention informatique est de dire que '0' correspond à pas d'action et '1' à une action.

Je ne serai pas du tout parti sur un tout autre code ...

Le but est d'utiliser les timer en 'C/C++' pour les points suivants :
*) éviter d'avoir des boucles 'for' dans le programme.
*) éviter d'utiliser la commande "delay".
*) décomposer chaque tâche (bouton 1, bouton 2, leds) d'une manière unitaire.
*) pouvoir intervenir sur chaque tâche en parallèle et en temps réel.
*) donner à chaque timer un intervalle de temps pour déclencher la tâche correspondante.

mais comme disait l'autre : "il y a autant de solution différente que de programmeurs pour les coder"

Il n'y a pas qu'une seule solution à ce genre de problème. A chacun sa façon de faire.

Pour les pull-up pull-down, ca fonctionne comme tu as pu le voir sur les ESP ou les arduino.

C'est ce que j'ai vu sur le net. Mais cela n'explique pas pourquoi certains (les électroniciens) préfèrent le pull-up.
C'est cette raison que je ne saisie pas.

Sinon, comme je le disais, pour un exemple aussi simple, il est plus judicieux d'utiliser le kernel que la librairie BMC ... car les API du kernel fonctionneront quelque soit la machine (même sur un PC s'il a des GPIO ... ce qui est parfois le cas pour ses LED) et pas uniquement sur la Framboise.

Je suis d'accord, mais j'ai suivi le conseil de bud spencer, à savoir utiliser la bibliothèque bcm2835.

J'ai terminé le programme 'C'. Il a été testé et il fonctionne correctement.

@+

[Bud Spencer]

Comme je n'y connais rien en électronique, je ne sais pas faire la différence entre les quatre solutions proposées.

Un 'pull' est une résistance interne qui definie juste l’état initial (entendons par initial celui de la pin en entrèe qui n’est connecté a rien). Si tu actives un pull_UP (1, TRUE, HIGHT), l’état initial de la pin sera à 1 et son état ne pourra passer à 0 qu’en la connectant au moins (gnd). En pull_DOWN (0, FALSE, LOW), c’est juste l’inverse. L’état initial de la pin sera à 0 et il passera à 1 quand tu appliqueras une tension positive (ici du 3.3v). En fait une pin en entrée est flottante. Elle n’a pas d’état initial au sens strict du terme et les résistances de pull servent justement à lui en donner un. En fonction de ce choix, tu sais juste qu’il faut appliquer l’inverse du pull sur la pin pour faire changer son etat. Reste la configuration sans pull qui te permet soit d’utiliser une résistance sur ton circuit extérieur ou alors d’y raccorder un circuit logique qui n’en a pas besoin (tu verras ca plus tard …).

cela n'explique pas pourquoi certains (les électroniciens) préfèrent le pull-up. C'est cette raison que je ne saisie pas.

Tout simplement parce que tu ne dois pas utiliser le 3.3volt fournie par le soc pour alimenter quoi que ce soit ni meme retrouver cette source tension sur ton montage extérieur et que la seule référence qu’il peut y avoir entre le pi et ton montage extérieur s’il en est, c’est la masse (gnd). Ainsi, meme si ton montage extérieur est alimenté en 1.2 ou 3.3 ou 5 ou 9 ou 12v …. Il sera très facile de faire basculer une entrée sur le pi en la raccordant (de quelques manières que ce soit) à la masse commune. SI en revanche tu utilises du pull_down, tu devras contrôler la tension que tu vas appliquer à tes entrées pour etre sur qu’elle soit suffisante et ne dépasse jamais la tension maxi supporté par celle-ci (en l’occurrence 3.3v) et qui ne sera pas forcement celle de ton montage.

La convention informatique est de dire que '0' correspond à pas d'action et '1' à une action.

Quelle convention ? Ramené à une logique booléenne, 1 signifie Vrai et 0 signifie Faux et Il est tout aussi juste d’ecrire :
- Il est Vrai que le bouton n’est pas enfoncé (cas pull_up avec bouton relié au gnd)
Que
- Il est vrai que le bouton est enfoncé (cas pull_down avec buton relié au 3.3v)

D’un point de vue rationnel, cela a l’air de te troubler que l’on puisse interpréter un état bas comme une action positive, mais il va falloir t’y faire. Quand tu évolueras dans la logique (au sens booléen) électronique, tu verras que ce cas est très majoritaire et que de très nombreux circuits logique ont par exemple une broche ‘enable’ ou ‘reset’ qui est active à la mise à 0.

[Artemus24]

Salut Bud Spencer.

En fait une pin en entrée est flottante.

Merci de l'indiquer car je ne comprends pas trop ce que cela signifie exactement.
Si la GPIO (ton PIN) est relié à quelque chose, elle a l'état de ce quelque chose, non ?
Et si elle n'est pas relié, pourquoi devrait-elle fluctuer ?

En lisant sur le net les documents consacrés aux pull up et pull down, j'ai surtout compris une chose, un interrupteur forme un court-circuit.
Pour éviter de griller la GPIO (et de surcroit la Raspberry), on insère une résistance afin de diminuer le flux de l'intensité.
A bien comprendre, on ne peut pas éviter le court-circuit, mais tout ce que l'on peut faire, c'est diminuer l'intensiter.
Quelle est la valeur de cette intensité minimal pour laquelle, il n'y a pas de court-circuit ? Est-ce que je raisonne juste ?

En électricité, on insère une lampe pour éviter ce court-circuit. Est-ce que la résistance joue le même rôle que la lampe ?

Elle n’a pas d’état initial au sens strict du terme et les résistances de pull servent justement à lui en donner un.

Après mes recherche sur le net, c'est ce que j'ai compris.
Cette résistance se nomme "résistance de tirage", car selon le modèle choisit, elle tire vers le haut (pull-up), ou vers le bas (pull-down) l'état initial.

Je pense qu'il me manque les seuils de tension pour déterminer l'état à 0 ou l'état à 1.
J'ai pu lire que le seuil minimal est de 0,8Vcc et 2Vcc pour une alimentation de 3,3Vcc.
Entre 0Vcc et 0,8VCC, c'est l'état 0 et entre 2Vcc et 3,3VCC, c'est l'état 1. Entre 0,8Vcc et 2Vcc, l'état est indéfini.

Pour les autres configurations (sans résistance externe), j'ai compris qu'il existe une résistance de tirage interne de 50k ohms.
Du coup, on peut se passer de la résistance de tirage externe, non ?

Reste la configuration sans pull qui te permet soit d’utiliser une résistance sur ton circuit extérieur ou alors d’y raccorder un circuit logique qui n’en a pas besoin (tu verras ça plus tard …).

Pour la différencier, je la nomme la résistance de sécurité qui est de 100 ohms.
A bien comprendre, elle sert à éviter de griller la GPIO si elle est en output (au lien de INPUT) et de lui appliquer un courant de 3,3Vcc.

D'où, je pense, l'intérêt de Pull-up qui applique un courant de 0Vcc quand on presse sur le bouton. Est-ce bien cela ?

Tout simplement parce que tu ne dois pas utiliser le 3.3volts fournie par le soc pour alimenter quoi que ce soit ...

Pas même une led ? Si je comprends bien ton raisonnement, sur la plaque de montage, je dois utiliser une alimentation qui sera indépendante de celle de la raspberry.

... et que la seule référence qu’il peut y avoir entre le pi et ton montage extérieur s’il en est, c’est la masse (gnd).

C'est une règle qu'il faut savoir ! D'où l'intérêt de Pull-up, si j'ai bien compris.

Ainsi, même si ton montage extérieur est alimenté en 1.2 ou 3.3 ou 5 ou 9 ou 12v …. Il sera très facile de faire basculer une entrée sur le pi en la raccordant (de quelques manières que ce soit) à la masse commune.

Je comprends tout l'intérêt de la masse. Mais dans l'exemple du Pull-up, il y a trois branches dans notre interrupteur.
Pour le GPIO, c'est coté Raspberry.
Pour le 3,3Vcc, je le prends où ? Sur la Raspberry ou sur l'alimentation de la plaque de montage.
Et la masse ? Je déduis qu'elle provient bien de la plaque de montage.

SI en revanche tu utilises du pull-down, tu devras contrôler la tension que tu vas appliquer à tes entrées pour être sûr qu’elle soit suffisante et ne dépasse jamais la tension maxi supporté par celle-ci (en l’occurrence 3.3v) et qui ne sera pas forcement celle de ton montage.

Là, ce n'est pas clair du tout. J'ai dans mon nouveau schéma du pull-down, deux résistances, l'une en tirage (10k ohms) et l'autre en sécurité (100 ohms).

Le courant circule bien de l'anode vers la cathode, non ? Donc du 3,3Vcc vers la masse.
Il y a deux résistances, l'une de 10K ohms sur la branche allant vers la masse et l'autre de 100 ohms sur la branche allant vers la GPIO.
En toute logique, le courant va circuler vers les deux branches, vers la GPIO et la masse.
Mais elle circulera plus facilement vers la branche offrant la moindre résistance.
Dans tous les cas, le courant circule dans les deux branches. Dois-je comprends qu'il y a un court-circuit ?
Et comment va se réguler le flux, vers la GPIO et vers la masse ?

Quelle convention ?

Celle-ci : logique binaire que l'on nomme aussi logique positive.

D’un point de vue rationnel, cela a l’air de te troubler que l’on puisse interpréter un état bas comme une action positive, mais il va falloir t’y faire.

C'est vrai que cela me trouble. C'est comme si je devais connaitre à l'avance le type de logique, négative ou positive.
Alors que jusqu'à présent, je faisais que de la logique positive.

Quand tu évolueras dans la logique (au sens booléen) électronique, tu verras que ce cas est très majoritaire et que de très nombreux circuits logique ont par exemple une broche ‘enable’ ou ‘reset’ qui est active à la mise à 0.

Autrement dit, de la logique négative.

Donc, pour l'interrupteur, je dois appliquer un pull-up afin de relier la GPIO à la masse quand le bouton est pressé.
Et quand est-il de la résistance de sécurité ? Utile ou pas ?

En fait, il me manque des données, pour mieux comprendre d'une part les chiffres (valeur des résistances, les seuils, les intensités, ...) et d'autre part comment fonctionne les circuits basés sur les leds et les interrupteurs.

@+

[destroyedlolo]

Salut Artemus24,

je répond rapidement pour te faire avancer car je n'ai pas trop de temps.

Si la GPIO (ton PIN) est relié à quelque chose, elle a l'état de ce quelque chose, non ?
Et si elle n'est pas relié, pourquoi devrait-elle fluctuer ?

Flottante indique qu'elle n'est relié à rien : le but des pull-up/down est justement de les forcer a un potentiel lorsque l'inter est en l'aire et donc ne force pas a un niveau.

En lisant sur le net les documents consacrés aux pull up et pull down, j'ai surtout compris une chose, un interrupteur forme un court-circuit.
Pour éviter de griller la GPIO (et de surcroit la Raspberry), on insère une résistance afin de diminuer le flux de l'intensité.
A bien comprendre, on ne peut pas éviter le court-circuit, mais tout ce que l'on peut faire, c'est diminuer l'intensiter.
Quelle est la valeur de cette intensité minimal pour laquelle, il n'y a pas de court-circuit ? Est-ce que je raisonne juste ?

Il n'y a CC que lorsque le GPIO est connecté en SORTIE. Maintenant, comme il y a toujours des états transitoire pas toujours connu (voir maitrisé comme avec les ESP) au démarrage, les regles de bonnes conduites sont :

• de ne pas utiliser de contact fermé / d'interrupteur bistable / ... (et donc pouvant crée de court-cuircuit) sur les GPIO pouvant etre en Entrée comme en sortie
• si ce n'est pas possible, par exemple avec les fins de course, y ajouté une résistance de limitation comme tu l'indiques

Pour la valeur de la résistance, loi d'ohm : tension (donc ici 3.3v) / intensité maximum admissible par le GPIO. Si ca ne te donne pas une valeur exacte, tu prend celle suppérieure.
Par exemple, si ca te donnait 112ohm, tu prendrais 150 qui est de mémoire la résistance normalisé supérieure.
Tu peux mettre meme plus, mais au bout d'un moment, ca va te rendre plus sensible aux parasites.

En électricité, on insère une lampe pour éviter ce court-circuit. Est-ce que la résistance joue le même rôle que la lampe ?

Sauf qu'une ampoule ballaste a une résistance très faible à froid donc avant qu'elle ne soit allumé. C'est très utilisé par exemple en modelime ferroviaire ou il y a par définition pleins de CC mais les alim sont sensée etre tolérante à ce genre de CC bref, mais ce n'est absolument pas adapté a un GPIO

Et quand est-il de la résistance de sécurité ? Utile ou pas ?

Dans l'absolue, si tu es sur que personne n'appuiera sur le bouton lors de la mise sous tension du PI et si tu es sur que le GPIO ne sera qu'en entrée, ce n'est pas nécessaire.
Maintenant, comme tu es en periode de teste (et qu'accessoirement, tu n'es pas spécialement sur de toi, ce qui est normal), j'en mettrai quand même une histoire d'éviter de griller quoi que ce soit.

A+

[Bud Spencer]

Si la GPIO (ton PIN) est relié à quelque chose, elle a l'état de ce quelque chose, non ?

Si on parle d’une entrée, alors oui.

Et si elle n'est pas relié, pourquoi devrait-elle fluctuer ?

Parce qu’elle serait très sensible à tous ce qui se passe autour d’elle (parasite, induction, répartition des courants a l’interieur meme de l’uc …)

En électricité, on insère une lampe pour éviter ce court-circuit. Est-ce que la résistance joue le même rôle que la lampe ?

On peut dire ça. Si quand tu allumes le fusible ne grille pas, c’est parce que ton ampoule limite le courrant dans le circuit fermé, donc électriquement parlant, avant d’etre une ampoule, c’est avant tout une résistance.

Cette résistance se nomme "résistance de tirage", car selon le modèle choisit, elle tire vers le haut (pull-up), ou vers le bas (pull-down) l'état initial.

On dit résistance de tirage quand on parle d’une résistance de pull up. Dans le cas d’un pull down, cela s’appelle une résistance de rappel.

Pour les autres configurations (sans résistance externe), j'ai compris qu'il existe une résistance de tirage interne de 50k ohms.
Du coup, on peut se passer de la résistance de tirage externe, non ?

Exactement. Il y a en fait 2 résistances interne par entrée. Une qui relie l’entrée et le + (pullup) et une qui relie l’entrée au gnd (pulldown) et tu actives (ou pas) l’une ou l’autre de ces résistance en utilisant les instructions de pull dans ton programme.

Pas même une led ? Si je comprends bien ton raisonnement, sur la plaque de montage, je dois utiliser une alimentation qui sera indépendante de celle de la raspberry.

Et bien non, pas meme une led. La consomation moyenne d’une led est de ~15 mA et meme si le soc peut le tolérer, il n’est absolument pas fait pour ça. Si tu veux allumer une led avec une gpio,une bonne pratique est d’alimenter l’anode de ta led par une source de tension autre que celle de l’uc et de piloter un dispositif qui va relayer la cathode à la masse commune. La méthode la plus basic est d’utiliser un transistor NPN monté en émetteur commun. Avec cette méthode, tu peux faire clairer ta led pleinement, qu’elle que soit la tension de ton montage externe (U) et en ne tirant que quelques µA sur le soc du PI. Pour imager (dessin de droite), dit toi ici que le transistor est un bouton poussoir commandé par la sortie haute du gpio et que cette action ne consomme que très peu de courrant. Le choix du transistor n’est qu’un exemple mais il y a fort heureusement une multitude de façons d’exploiter CORRECTEMENT les états des gpio du Pi (ou d’un autre µc) que ce soit en entrée ou en sortie. Bien sur, ici on en est au stade expérimental, donc comme le soc, on peu tolérer la led directe sur une sortie, mais il ne faut surtout pas considérer ca comme valable.

sans-titre.png (22.51 Kio) Vu 5453 fois

Le courant circule bien de l'anode vers la cathode, non ? Donc du 3,3Vcc vers la masse.
Il y a deux résistances, l'une de 10K ohms sur la branche allant vers la masse et l'autre de 100 ohms sur la branche allant vers la GPIO.
En toute logique, le courant va circuler vers les deux branches, vers la GPIO et la masse.
Mais elle circulera plus facilement vers la branche offrant la moindre résistance.
Dans tous les cas, le courant circule dans les deux branches. Dois-je comprends qu'il y a un court-circuit ?
Et comment va se réguler le flux, vers la GPIO et vers la masse ?

Là on touche une fois de plus aux carences de l’apprentissage moderne par internet. Écrirais-tu un livre si tu ne connaissais pas l’alphabet ou un minimum de grammaire ? Ferais tu du calcul si tu ne connaissais pas tes tables de multiplications et si tu ne savais pas compter ? Et bien pour l’électronique, c’est pareil. Si tu ne maitrise pas un minimum les bases de l’électricité, tu ne pourras pas faire d’électronique. La moindre des choses quand on se lance la dedans, c’est au minimum de pouvoir déterminer comment se réparti le courrant dans un circuit fermé. Pour ça, il y a 3 lois à fondamentales auxquelles je te renvois et qui sont : La loi d’Ohm, et 2 lois de Kirchhoff qui sont les Nœuds et les Mailles. Comme on parle aussi ici d’électronique numérique, cela requière aussi des connaissances en algèbre de Bool, mais ça, en tant que developpeur tu es déjà censé connaitre.

C'est vrai que cela me trouble. C'est comme si je devais connaitre à l'avance le type de logique, négative ou positive.
Alors que jusqu'à présent, je faisais que de la logique positive.

Non, la tu confonds type logique et interprétation des états. Au sens propre du terme, on parle de logique négative quand un état bas correspond à un potentiel de niveau haut et vice versa. Quand tu appliques du 3.3v sur une gpio en entré de ton PI, le bit du registre correspondant passe à 1 et quand tu lui appliques gnd il passe à 0. Idem pour les sorties. Ce n’est donc que de la logique positive. L’interprétation qui en est faite par ton programme n’a rien à voir la dedans.

Et quand est-il de la résistance de sécurité ? Utile ou pas ?

Bien sûr qu’elle peut protéger ton pi (dans certain cas seulement et si elle est correctement dimensionné), mais c’est comme pour l’alimentation d’une led. Il y a une multitude de façon de faire pour protéger les gpio et cette résistance que tu mets ne peut servir qu’à titre expérimental

[Artemus24]

Salut à tous.

Désolé Destroyedlolo si je n'ai pas répondu plutôt, j'ai attendu la réponse de Bud Spencer.
Et encore merci pour vos réponses.

Flottante indique qu'elle n'est relié à rien : le but des pull-up/down est justement de les forcer à un potentiel lorsque l'inter est en l'air et donc ne force pas à un niveau.

Justement, c'est ce principe du pull-up (ou pull-down) que je ne comprends pas.
Et plus particulièrement le rôle joué par la résistance (de tirage ou de rappel) et le calcul de leur valeur.

D'où mon exemple de lampe dans un circuit fermé qui fait office de résistance.
Mais quand à forcer un potentiel, là, je ne comprends pas.
Pour moi, une résistance est faite pour limiter l'intensité dans un circuit.
L'exemple de la led montre que si j'augmente la valeur de la résistance, la luminosité diminue.

Il n'y a CC que lorsque le GPIO est connecté en SORTIE.

Si je suis dans le cas de la led, donc la GPIO est en OUTPUT, c'est la GPIO qui produit la tension dont j'ai besoin.
La broche courte (cathode) de la led est relié à la masse (ground) et la broche longue (anode) à la GPIO.
Ce qui fait le court-circuit, c'est bien l'intensité qui passe dans le circuit. Est-ce bien cela ?

Je me trouve dans le cas de la GPIO en INPUT, comme dans le cas de l'interrupteur.
Et là, je vois deux problèmes :
1) si la GPIO n'est pas reliée, ou si la résistance est trop forte, elle est flottante, et je ne peux pas faire de mesure fiable.
2) si la GPIO est relié au 3,3Vcc, on se trouve dans un court-circuit.

D'où ma question précédente : quelle est la valeur maximale de l'intensité pour ne pas être en court-circuit ?
Enfin, j'espère que ma question à un sens, sinon, je ne comprends pas le rôle de la résistance.

Tu peux mettre même plus, mais au bout d'un moment, ça va te rendre plus sensible aux parasites.

Sensible aux parasites, je suppose que cela signifie que la GPIO est flottante.

Si la résistance est trop forte, la GPIO sera flottante.
Si la résistance est trop faible, la GPIO sera en cort-circuit.

Oui, mais voilà, j'ai cru comprendre que la lecture de l'état (0 ou 1) du GPIO se faisait en volt.
De 0Vcc à 0,9Vcc, c'est l'état 0 et de 1,6Vcc à 3,3Vcc c'est l'état 1. Entre 0,9Vcc et 1,6Vcc c'est un état intermédiaire considéré comme indéfini.
Et c'est là que je ne comprends plus rien, en quoi une résistance qui influence l'intensité a aussi une influence sur la tension ?

Dans la formule U = R * I, la constante est bien la tension, non ?

Parce qu’elle serait très sensible à tous ce qui se passe autour d’elle (parasite, induction, répartition des courants à l'intérieur même de l’uc …)

La GPIO en INPUT et non reliée se compote comme une antenne radio.

Une qui relie l’entrée et le + (pullup) et une qui relie l’entrée au gnd (pulldown) et tu actives (ou pas) l’une ou l’autre de ces résistance en utilisant les instructions de pull dans ton programme.

Si je comprends bien, dans le cas du pull-up/down externe, il ne faut rien activer :

Code : Tout sélectionner

bcm2835_gpio_set_pud(KEY_a, BCM2835_GPIO_PUD_OFF);

Et dans le cas du pull-up/down interne, il faut activer le mode pull-up :

Code : Tout sélectionner

bcm2835_gpio_set_pud(KEY_a, BCM2835_GPIO_PUD_UP);

ou bien le mode pull-down interne dans le programme :

Code : Tout sélectionner

bcm2835_gpio_set_pud(KEY_a, BCM2835_GPIO_PUD_DOWN);

La méthode la plus basic est d’utiliser un transistor NPN monté en émetteur commun.

Déjà que j'ai des problèmes de compréhensions avec les résistances, si maintenant vous introduisez les transistors, je ne vais pas m'en sortir.

dit toi ici que le transistor est un bouton poussoir commandé par la sortie haute du gpio et que cette action ne consomme que très peu de courrant.

Pour le principe, je comprends. Mais dans le schéma, il y a une résistance Rb.
Que vient faire cette résistance, si justement le transistor consomme très peu ?
Dans ce montage, je suppose que la GPIO est en OUTPUT et non plus en INPUT. Est-ce bien cela ?

Là on touche une fois de plus aux carences de l’apprentissage moderne par internet.

Je ne serai pas en train de poser des questions si je savais y répondre.
A vrai dire, je n'ai jamais rien compris à l'électronique, par rapport à l'électricité qui me parait plus simple.

il y a 3 lois à fondamentales auxquelles je te renvois et qui sont : La loi d’Ohm, et 2 lois de Kirchhoff qui sont les Nœuds et les Mailles.

Tout ce que je connais en électricité, c'est ce que j'ai appris en première dans mes cours de physique.

Il y a une multitude de façon de faire pour protéger les gpio et cette résistance que tu mets ne peut servir qu’à titre expérimental

Je suis parti sur le schéma suivant :



Je suis dans le cas de la raspberry, voire de l'arduino, et tout ce que j'essaye de comprendre et de faire, est de savoir si ce schéma est correcte ou pas.
La petite différence par rapport au schéma est que j'ai du 3,3Vcc et non du 5Vcc.
A cela, j'aimerai savoir comme évaluer les deux résistances de rappel et de protection ?

Dans le cas de la résistance de rappel, l'intensité est de I = 3,3Vcc / 10K ohms, soit I = 0,33mA.
Dans le cas de la résistance de rappel interne, elle est de 50K ohms et donne un I = 0,066mA.

Je ne sais pas interpréter ce 0,33mA et ce 0,066Ma ?

De plus, par rapport à ma question ci-dessus concerant la valeur maximale de l'intensité pour ne pas provoquer de court-circuit est-elle proche de l'une de ces deux valeurs ?

Et quand est-il de forcer la stabilité des états à 0 ou à 1 ?

@+