Linux sunxi armbian gpio - Historique des versions

Jc.forton : /* Principe */

2021-06-15T08:26:21Z

Principe

← Version précédente		Version du 15 juin 2021 à 10:26
Ligne 358 :		Ligne 358 :
	{\|		{\|
	\|-		\|-
	\|\|[[Fichier:Pwm duty cycle example.png\|centré\|400px]]		\|valign="top"\|[[Fichier:Pwm duty cycle example.png\|centré\|400px]]
	\|width="5px"\|		\|width="5px"\|
	\|style="vertical-align:top"\|La modulation PWM génère un signal carré. On va modifier le temps où le signal sera à un état haut (ici 5v) et le temps où il sera à un état bas (ici 0v). Le rapport entre ces deux durées s'appelle le cycle de travail (duty cycle).		\|style="vertical-align:top"\|
			La modulation PWM génère un signal carré. On va modifier le temps où le signal sera à un état haut (ici 5v) et le temps où il sera à un état bas (ici 0v). Le rapport entre ces deux durées s'appelle le cycle de travail (duty cycle).

	* Sur la première image, le signal est constamment à un état bas, ce qui implique que le cycle de travail est de 0% (0/100).		* Sur la première image, le signal est constamment à un état bas, ce qui implique que le cycle de travail est de 0% (0/100).
Ligne 377 :		Ligne 378 :

	Dans le cas où la période du cycle de travail est de 1 seconde, soit une fréquence de 1Hz, on voit clairement la led clignoter car on ne dépasse pas les 24 images par seconde qui permettent d'atteindre la persistance rétinienne. On peut monter progressivement pour observer ce phénomène s'atténuer vers 30Hz (30 images par secondes) mais il faudra atteindre 250Hz soit une période de 4ms pour que le phénomène de scintillement disparaisse complétement !		Dans le cas où la période du cycle de travail est de 1 seconde, soit une fréquence de 1Hz, on voit clairement la led clignoter car on ne dépasse pas les 24 images par seconde qui permettent d'atteindre la persistance rétinienne. On peut monter progressivement pour observer ce phénomène s'atténuer vers 30Hz (30 images par secondes) mais il faudra atteindre 250Hz soit une période de 4ms pour que le phénomène de scintillement disparaisse complétement !
	{\|		\|}
			{\|align="center"
	\|-		\|-
	\|\|		\|\|
Ligne 412 :		Ligne 414 :
	\|align="center"\|		\|align="center"\|
	250Hz		250Hz
	\|}
	\|}		\|}

Jc.forton : /* Principe */

2020-10-10T16:20:29Z

Principe

← Version précédente		Version du 10 octobre 2020 à 18:20
Ligne 362 :		Ligne 362 :
	\|style="vertical-align:top"\|La modulation PWM génère un signal carré. On va modifier le temps où le signal sera à un état haut (ici 5v) et le temps où il sera à un état bas (ici 0v). Le rapport entre ces deux durées s'appelle le cycle de travail (duty cycle).		\|style="vertical-align:top"\|La modulation PWM génère un signal carré. On va modifier le temps où le signal sera à un état haut (ici 5v) et le temps où il sera à un état bas (ici 0v). Le rapport entre ces deux durées s'appelle le cycle de travail (duty cycle).

	* ~~Dans~~ la première image, le signal est constamment à un état bas, ce qui implique que le cycle de travail est de 0% (0/100).		* Sur la première image, le signal est constamment à un état bas, ce qui implique que le cycle de travail est de 0% (0/100).

	* ~~Dans~~ la deuxième image, le signal reste 1/4 du temps à un état haut et le reste de temps à un état bas. Le cycle de travail est de 25% (1/4).		* Sur la deuxième image, le signal reste 1/4 du temps à un état haut et le reste de temps à un état bas. Le cycle de travail est de 25% (1/4).

	* ~~Dans~~ la troisième image, le signal reste la moitié du temps à un état haut et l'autre moitié à un état bas. Le cycle de travail est de 50% (1/2).		* Sur la troisième image, le signal reste la moitié du temps à un état haut et l'autre moitié à un état bas. Le cycle de travail est de 50% (1/2).

	* ~~Dans~~ la quatrième image, le signal reste les 3/4 du temps à un état haut et 1/4 de temps à un état bas. Le cycle de travail est de 75% (3/4).		* Sur la quatrième image, le signal reste les 3/4 du temps à un état haut et 1/4 de temps à un état bas. Le cycle de travail est de 75% (3/4).

	* ~~Dans~~ la dernière image, le signal reste tout le temps à un état haut. Le cycle de travail est de 100%.		* Sur la dernière image, le signal reste tout le temps à un état haut. Le cycle de travail est de 100%.

	Le cycle se répète ainsi et la durée d'une répétition s'appelle période.		Le cycle se répète ainsi et la durée d'une répétition s'appelle période.

Jc.forton : /* Application */

2020-07-06T13:00:22Z

Application

@@ Ligne 562 : / Ligne 562 : @@
 |width="5px"|
 |align="center"| SIGALRM
 |-
 ||[[Fichier:pwm_ttscope_sleep.png|centré|600px]]

Jc.forton : /* Écriture */

2020-07-01T10:08:50Z

Écriture

← Version précédente		Version du 1 juillet 2020 à 12:08
Ligne 320 :		Ligne 320 :
	int main(int argc, char * argv[]){		int main(int argc, char * argv[]){
	// ouverture du contrôleur en lecture seule		// ouverture du contrôleur en lecture seule
	int chip_fd = open(GPIO_CHIP, O_RDONLY)~~; int offset~~;		int chip_fd = open(GPIO_CHIP, O_RDONLY);
	// Structure contenant les informations de la ligne		// Structure contenant les informations de la ligne
	struct gpiohandle_request request;		struct gpiohandle_request request;

Jc.forton : /* Informations sur les broches */

2020-07-01T10:04:34Z

Informations sur les broches

← Version précédente		Version du 1 juillet 2020 à 12:04
Ligne 188 :		Ligne 188 :
	int main(int argc, char * argv[]){		int main(int argc, char * argv[]){
	// ouverture du contrôleur en lecture seule		// ouverture du contrôleur en lecture seule
	int chip_fd = open(GPIO_CHIP, O_RDONLY)~~; int offset~~;		int chip_fd = open(GPIO_CHIP, O_RDONLY);
	// Structure contenant les informations de la ligne		// Structure contenant les informations de la ligne
	struct gpiohandle_request request;		struct gpiohandle_request request;

Jc.forton : /* Application */

2020-06-25T13:54:15Z

Application

← Version précédente		Version du 25 juin 2020 à 15:54
Ligne 557 :		Ligne 557 :
	</source>		</source>
	Regardons la différence qu'il y a entre les deux méthodes:		Regardons la différence qu'il y a entre les deux méthodes:
			{\|
			\|-
			\|align="center"\| SLEEP
			\|width="5px"\|
			\|align="center"\| SIGALRM
			\|-
			\|\|[[Fichier:pwm_ttscope_sleep.png\|centré\|600px]]
			\|width="5px"\|
			\|\|[[Fichier:pwm_ttscope_alarm.png\|centré\|600px]]
			\|-
			\|\|[[Fichier:pwm_cpu_sleep.png\|centré\|600px]]
			\|width="5px"\|
			\|\|[[Fichier:pwm_cpu_alarm.png\|centré\|600px]]
			\|}
			On voit que l'on est légèrement plus précis sur les timing avec les signaux mais que l'on consomme deux fois plus de CPU...

Jc.forton : /* Application */

2020-06-25T12:56:49Z

Application

← Version précédente		Version du 25 juin 2020 à 14:56
Ligne 416 :		Ligne 416 :

	== Application ==		== Application ==
			Ci-dessous un script qui met en application la génération d'un signal PWM.
			Ce script utilise deux approches différentes:
			* la fonction sleep
			* les signaux POSIX(avec SIGALRM)

			<source lang="c">
			#include <stdio.h> // pour EXIT_SUCCESS
			#include <stdlib.h> // pour printf
			#include <linux/gpio.h> // pour struct gpiochip_info
			#include <fcntl.h> // pour open
			#include <sys/ioctl.h> // pour ioctl
			#include <string.h> // Pour memset
			#include <unistd.h>
			#include <signal.h>
			#include <sys/time.h>
			#include <inttypes.h>

			// Macro pour le nom du contrôleur
			#define GPIO_CHIP "/dev/gpiochip0"
			#define PWM_PULSE 4000 // Durée totale d'une impulsion

			#define ON 1
			#define OFF 0

			// Structure contenant les informations de la ligne
			struct gpiohandle_request request;
			// Structure contenant les valeurs de la ligne
			struct gpiohandle_data data;

			void sleep_pwm();
			void setGpio();
			void setState(int state);
			void sigint_handler(int signum);
			void sigalrm_handler();
			void showUsage(char * program);

			int GPIO, DUTY_CYCLE, ON_DURATION, OFF_DURATION;

			int main (int argc, char * argv[]){
			signal(SIGINT, sigint_handler);
			if(argc < 2){
			showUsage(argv[0]);
			exit(1);
			}
			GPIO = strtol(argv[1], NULL, 10);
			if(argc < 3){
			showUsage(argv[0]);
			exit(1);
			}
			DUTY_CYCLE = strtol(argv[2], NULL, 10);
			ON_DURATION = DUTY_CYCLE * PWM_PULSE / 100;
			OFF_DURATION = (100 - DUTY_CYCLE) * PWM_PULSE / 100;
			if(argc < 4){
			printf("Missing method\n");
			showUsage(argv[0]);
			exit(1);
			}
			int method = -1;
			if(argc > 2){
			if(strcmp(argv[3], "-s") == 0){
			method = 0;
			}else if(strcmp(argv[3], "-a") == 0){
			method = 1;
			}else{
			showUsage(argv[0]);
			exit(1);
			}
			}
			setGpio();
			printf("Starting %i% PWM signal on GPIO %i with %s method\n", DUTY_CYCLE, GPIO, method == 0 ? "sleep" : "alarm");
			if(method == 0){
			sleep_pwm();
			}else{
			signal(SIGALRM, sigalrm_handler);
			raise(SIGALRM);
			while(1){
			sleep(10);
			}
			}
			return EXIT_SUCCESS;
			}

			void sleep_pwm(){
			while(1){
			if(data.values[0] == OFF){
			setState(ON);
			usleep(ON_DURATION);
			}else{
			setState(OFF);
			usleep(OFF_DURATION);
			}
			}
			}

			void setGpio(){
			// ouverture du contrôleur en lecture seule
			int chip_fd = open(GPIO_CHIP, O_RDONLY); int offset;
			// Initialisation de la structure avec des zéro
			memset(&request, 0, sizeof(struct gpiohandle_request));
			// Positionnement du numéro de la ligne à lire
			request.lineoffsets[0] = GPIO;
			// Paramètrage de la direction (OUTPUT)
			request.flags = GPIOHANDLE_REQUEST_OUTPUT;
			// Quantité de ligne a traiter
			request.lines = 1;
			// Récupération du descripteur de la ligne
			ioctl(chip_fd, GPIO_GET_LINEHANDLE_IOCTL, &request);
			// Paramètrage d'un niveau logique haut
			data.values[0] = 0;
			// Ecriture du niveau logique
			ioctl(request.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &data);
			}

			void setState(int state){
			data.values[0] = state;
			ioctl(request.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &data);
			}

			void sigint_handler(int signum){
			setState(OFF);
			exit(0);
			}

			void sigalrm_handler (int signum){
			if(data.values[0] == OFF){
			setState(ON);
			ualarm(ON_DURATION, 0);
			}else{
			setState(OFF);
			ualarm(OFF_DURATION, 0);
			}
			}

			void showUsage(char * program){
			printf("Usage : %s GPIO DUTY_CYCLE METHOD\n", program);
			printf("\tGPIO: any GPIO present on gpiochip0\n");
			printf("\tDUTY_CYCLE: any number between 0 - 100 (%)\n");
			printf("\tMETHOD: -a for alarm signal method, -s for sleep function method\n");
			}
			</source>
			Regardons la différence qu'il y a entre les deux méthodes:

Jc.forton : /* Principe */

2020-06-21T18:12:38Z

Principe

Jc.forton : /* Écriture */

2020-06-21T18:08:35Z

Écriture

← Version précédente		Version du 21 juin 2020 à 20:08
Ligne 304 :		Ligne 304 :

	== Écriture ==		== Écriture ==
	Dans l'exemple suivant, on change la direction de la ligne 6 du contrôleur gpiochip0. Nous allons créer le fichier set_value.c:		Dans l'exemple suivant, on change la direction de la ligne 6 du contrôleur gpiochip0. Nous allons créer le fichier set_value.c :
	<source lang="c">		<source lang="c">
	#include <stdio.h> // pour EXIT_SUCCESS		#include <stdio.h> // pour EXIT_SUCCESS
Ligne 347 :		Ligne 347 :
	}		}
	</source>		</source>
	Une fois compilé, on peut changer la direction de la ligne 6 du contrôleur gpiochip0:		Une fois compilé, on peut changer la direction de la ligne 6 du contrôleur gpiochip0 :
	<pre>		<pre>
	# gcc -o set_value.bin set_value.c		# gcc -o set_value.bin set_value.c

Jc.forton : /* Direction */

2020-06-21T18:08:10Z

Direction

← Version précédente		Version du 21 juin 2020 à 20:08
Ligne 222 :		Ligne 222 :
	= Modification =		= Modification =
	== Direction ==		== Direction ==
	Dans le programme précédent, on a déjà abordé sans le vouloir la modification de la direction d'une broche. Le programme suivant répète les ~~même~~ opérations mais de manière un peu plus structurée et va changer la direction de la ligne 199 du contrôleur gpiochip0. Nous allons créer le fichier set_mode.c:		Dans le programme précédent, on a déjà abordé sans le vouloir la modification de la direction d'une broche. Le programme suivant répète les mêmes opérations mais de manière un peu plus structurée et va changer la direction de la ligne 199 du contrôleur gpiochip0. Nous allons créer le fichier set_mode.c:
	<source lang="c">		<source lang="c">
	#include <stdio.h> // pour EXIT_SUCCESS		#include <stdio.h> // pour EXIT_SUCCESS
Ligne 295 :		Ligne 295 :
	}		}
	</source>		</source>
	Une fois compilé, on peut changer la direction de la ligne 199 du contrôleur gpiochip0:		Une fois compilé, on peut changer la direction de la ligne 199 du contrôleur gpiochip0 :
	<pre>		<pre>
	# gcc -o set_mode.bin set_mode.c		# gcc -o set_mode.bin set_mode.c

← Version précédente		Version du 21 juin 2020 à 20:12
Ligne 355 :		Ligne 355 :
	= PWM logiciel =		= PWM logiciel =
	== Principe ==		== Principe ==
	Pour modifier la luminosité d'une LED il faut générer un signal [https://fr.wikipedia.org/wiki/Modulation_de_largeur_d%27impulsion PWM] et le cycle de travail va déterminer le niveau de luminosité perçu par l’œil grâce au phénomène de [https://fr.wikipedia.org/wiki/Persistance_r%C3%A9tinienne persistance rétinienne].		Pour modifier la luminosité d'une LED, il faut générer un signal [https://fr.wikipedia.org/wiki/Modulation_de_largeur_d%27impulsion PWM] et le cycle de travail va déterminer le niveau de luminosité perçu par l’œil grâce au phénomène de [https://fr.wikipedia.org/wiki/Persistance_r%C3%A9tinienne persistance rétinienne].
	{\|		{\|
	\|-		\|-
	\|\|[[Fichier:Pwm duty cycle example.png\|centré\|400px]]		\|\|[[Fichier:Pwm duty cycle example.png\|centré\|400px]]
	\|width="5px"\|		\|width="5px"\|
	\|style="vertical-align:top"\|La modulation PWM génère un signal carré ~~qui sur lequel on~~ va ~~influer sur les durées ou~~ le signal sera à un état haut (ici 5v) et à un état bas (ici 0v). le rapport entre ces deux ~~durée~~ s'appelle le cycle de travail (duty cycle).		\|style="vertical-align:top"\|La modulation PWM génère un signal carré. On va modifier le temps où le signal sera à un état haut (ici 5v) et le temps où il sera à un état bas (ici 0v). Le rapport entre ces deux durées s'appelle le cycle de travail (duty cycle).

	* Dans la première image, le signal est constamment à un état bas, ce qui implique que le cycle de travail est de 0% (0/100)		* Dans la première image, le signal est constamment à un état bas, ce qui implique que le cycle de travail est de 0% (0/100).

	* Dans la deuxième image, le signal reste 1/4 du temps à un état haut et le reste de temps à un état bas. Le cycle de travail est de 25% (1/4)		* Dans la deuxième image, le signal reste 1/4 du temps à un état haut et le reste de temps à un état bas. Le cycle de travail est de 25% (1/4).

	* Dans la troisième image, le signal reste la moitié du temps à un état haut et l'autre moitié à un état bas. Le cycle de travail est de 50% (1/2)		* Dans la troisième image, le signal reste la moitié du temps à un état haut et l'autre moitié à un état bas. Le cycle de travail est de 50% (1/2).

	* Dans la quatrième image, le signal reste les 3/4 du temps à un état haut et 1/4 de temps à un état bas. Le cycle de travail est de 75% (3/4)		* Dans la quatrième image, le signal reste les 3/4 du temps à un état haut et 1/4 de temps à un état bas. Le cycle de travail est de 75% (3/4).

	* Dans la dernière image, le signal reste tout le temps à un état haut. Le cycle de travail est de 100%		* Dans la dernière image, le signal reste tout le temps à un état haut. Le cycle de travail est de 100%.

	Le cycle se répète ainsi et la durée d'une répétition s'appelle période.		Le cycle se répète ainsi et la durée d'une répétition s'appelle période.

	Plus la période est petite et donc plus les alternances sont rapprochées et plus cela demande de CPU mais plus la led brille de manière stable et moins cette impression de scintillement se fait ressentir.		Plus la période est petite et donc plus les alternances sont rapprochées, plus cela demande de CPU mais plus la led brille de manière stable et moins cette impression de scintillement se fait ressentir.

	Dans le cas ou la période du cycle de travail est de 1 seconde, soit une fréquence de 1Hz, on voit clairement la led clignoter car on ne dépasse pas les 24 images par ~~secondes~~ qui permettent d'atteindre la persistance rétinienne. On peut monter progressivement pour observer ce phénomène s'atténuer vers 30Hz (30 images par secondes) mais il faudra atteindre 250Hz soit une période de 4ms pour que le phénomène de scintillement disparaisse complétement !		Dans le cas où la période du cycle de travail est de 1 seconde, soit une fréquence de 1Hz, on voit clairement la led clignoter car on ne dépasse pas les 24 images par seconde qui permettent d'atteindre la persistance rétinienne. On peut monter progressivement pour observer ce phénomène s'atténuer vers 30Hz (30 images par secondes) mais il faudra atteindre 250Hz soit une période de 4ms pour que le phénomène de scintillement disparaisse complétement !
	{\|		{\|
	\|-		\|-

Linux sunxi armbian gpio - Historique des versions

Jc.forton : /* Principe */

Jc.forton : /* Principe */

Jc.forton : /* Application */

Jc.forton : /* Écriture */

Jc.forton : /* Informations sur les broches */

Jc.forton : /* Application */

Jc.forton : /* Application */

Jc.forton : /* Principe */

Jc.forton : /* Écriture */

Jc.forton : /* Direction */

Jc.forton : /* Principe */

Jc.forton : /* Principe */

Jc.forton : /* Application */

Jc.forton : /* Écriture */

Jc.forton : /* Informations sur les broches */

Jc.forton : /* Application */

Jc.forton : /* Application */

Jc.forton : /* Principe */

Jc.forton : /* Écriture */

Jc.forton : /* Direction */