SE4Binome2023-8 - Historique des versions

Ncazin : /* Matériel : */

2024-01-16T12:28:47Z

Matériel :

← Version précédente		Version du 16 janvier 2024 à 12:28
Ligne 420 :		Ligne 420 :
	[[Fichier:WhatsApp Video 2023-12-21 at 11.58.12.mp4\|centré\|vignette\|Carte RNDIS réagissant à notre propre trame]]		[[Fichier:WhatsApp Video 2023-12-21 at 11.58.12.mp4\|centré\|vignette\|Carte RNDIS réagissant à notre propre trame]]

	Cependant, on remarque que la LED s'allume, c'est-à-dire que la réponse est bien créée, mais elle n'est pas envoyée. En remontant chaque fonction pouvant être la cause du non-envoi de la réponse, nous avons "RNDIS_Task" que nous n'arrivons pas à comprendre. Cependant, nous n'avons pas modifié cette fonction, cela doit provenir de la trame envoyée, mais pourtant, le programme rentre bien complétement dans la fonction. À ce stade nous n'arrivons toujours pas à trouver la cause du problème.		Cependant, on remarque que la LED s'allume, c'est-à-dire que la réponse est bien créée, mais elle n'est pas envoyée. En remontant chaque fonction pouvant être la cause du non-envoi de la réponse, nous avons "RNDIS_Task" que nous n'arrivons pas à comprendre. Cependant, nous n'avons pas modifié cette fonction, cela doit provenir de la trame envoyée, mais pourtant, le programme rentre bien complétement dans la fonction. À ce stade, nous n'arrivons toujours pas à trouver la cause du problème.

			== Conclusion : ==
			Durant ce projet, nous avons essayé de travailler sur toutes les parties. En effet, nous avons consacré beaucoup de temps sur la partie Ordonnanceur pendant que la carte électronique était expédiée, c'est d'ailleurs comme ça que nous avons réussi à terminer toutes les tâches. Nous avons rencontré beaucoup de difficultés pendant la programmation de l'ordonnanceur, certaines tâches étaient plus compliquées pour nous que d'autres, mais nous avons réussi à nous organiser et à réaliser ces tâches. Ensuite, nous nous sommes séparés en deux, un qui travaillait sur le VHDL et l'autre sur la carte RNDIS. Du côté de la partie VHDL, la gestion du SPI était compliquée à réalisée et nous n'avons pas eu le temps de tester notre programme sur une carte FPGA. Cependant, nous avons pu tester et beaucoup mieux avancer sur le VGA. Enfin, la carte RNDIS a été compliquée à comprendre et nous avons perdu beaucoup de temps sur la réduction de la pile TCP/IP. Nous avons quand même réussi à avancer jusqu'à ce blocage sur la réponse que l'on devait recevoir.

			Globalement, nous sommes contents du résultat de notre travail. Nous avons travaillé sur chaque partie comme nous le voulions afin de renforcer ou d'acquérir de nouvelles compétences. L'organisation entre nous nous a permis de gagner du temps sur notre travail. De plus, nous avons travaillé chez nous, ce qui nous permit aussi de mieux nous organiser et de mieux prévoir les séances de travail qui venaient.

	== Rendus : ==		== Rendus : ==
	Lien de notre GIT : https://archives.plil.fr/ncazin/Projet_Pico_SE4.git		Lien de notre GIT : https://archives.plil.fr/ncazin/Projet_Pico_SE4.git

Ncazin : /* Matériel : */

2023-12-29T10:35:56Z

Matériel :

Voir les modifications

Acegarra : Mise en page générale

2023-12-28T17:54:45Z

Mise en page générale

← Version précédente		Version du 28 décembre 2023 à 17:54
Ligne 164 :		Ligne 164 :
	== Carte FPGA/VHDL : ==		== Carte FPGA/VHDL : ==

	=== ~~'''~~Contrôleur de bus série SPI~~'''~~ ===		=== Contrôleur de bus série SPI ===
	Pour ce programme VHDL, nous avons voulu faire une communication SPI Maitre/Esclave. Pour cela , nous nous sommes documentés sur comment fonctionnait cette communication. Il faut alors réaliser les 4 signaux MOSI, MISO, SS et SCK afin de pouvoir communiquer. On vérifie alors chacun de bits envoyé afin de gérér les signaux de contrôle et de l'entrée MISO. Ensuite, on génère les données de sortie pour la réponse. Enfin on peut assigner les sorties avec les informations que l'on a. Voici alors les processus utilisés : <syntaxhighlight lang="vhdl">		Pour ce programme VHDL, nous avons voulu faire une communication SPI Maitre/Esclave. Pour cela , nous nous sommes documentés sur comment fonctionnait cette communication. Il faut alors réaliser les 4 signaux MOSI, MISO, SS et SCK afin de pouvoir communiquer. On vérifie alors chacun de bits envoyé afin de gérér les signaux de contrôle et de l'entrée MISO. Ensuite, on génère les données de sortie pour la réponse. Enfin on peut assigner les sorties avec les informations que l'on a. Voici alors les processus utilisés : <syntaxhighlight lang="vhdl">
	-- Processus 1 : Gestion des signaux de contrôle et de l'entrée MISO		-- Processus 1 : Gestion des signaux de contrôle et de l'entrée MISO
Ligne 216 :		Ligne 216 :
	</syntaxhighlight>		</syntaxhighlight>

	=== ~~'''~~Contrôleur VGA~~'''~~ ===		=== Contrôleur VGA ===
	Pour ce contrôleur, il faut utiliser le port VGA présent sur la carte Basys-3. Sur ce connecteur VGA, il y a plusieurs sorties à gérer. En effet, il y a les signaux de synchronisation HS et VS qui fonctionnent si ils ont une certaines formes d'ondes. Ces signaux doivent être à 0 pendant un certain temps. De plus, nous avons les ports permettant de gérer les couleur, vert, bleu et rouge, chacun sur 4 bits. L'horloge du FPGA fonctionnant à 100MHz, nous devons la moduler à 60Hz, car l'écran fonctionne à cette fréquence. Pour cela, nous avons utilisé les IP catalogs. Ce sont des composants existants dans des librairies qui peuvent être utilisés. Dans notre cas, nous avons utilisé un composant qui permet de modifier la fréquence d’un signal.		Pour ce contrôleur, il faut utiliser le port VGA présent sur la carte Basys-3. Sur ce connecteur VGA, il y a plusieurs sorties à gérer. En effet, il y a les signaux de synchronisation HS et VS qui fonctionnent si ils ont une certaines formes d'ondes. Ces signaux doivent être à 0 pendant un certain temps. De plus, nous avons les ports permettant de gérer les couleur, vert, bleu et rouge, chacun sur 4 bits. L'horloge du FPGA fonctionnant à 100MHz, nous devons la moduler à 60Hz, car l'écran fonctionne à cette fréquence. Pour cela, nous avons utilisé les IP catalogs. Ce sont des composants existants dans des librairies qui peuvent être utilisés. Dans notre cas, nous avons utilisé un composant qui permet de modifier la fréquence d’un signal.

Ligne 321 :		Ligne 321 :
	Après cela, nous allons entamé la programmation pour avoir une communication RNDIS.		Après cela, nous allons entamé la programmation pour avoir une communication RNDIS.

	=== ~~'''~~Programmation de la carte électronique RNDIS~~'''~~ ===		=== Programmation de la carte électronique RNDIS ===
	Pour la programmation de la carte électronique RNDIS, nous avons utilisé une démonstration LUFA déjà existante qui implémente une pile TCP/IP. En faisant directement un "make", nous avons remarqué que l'espace mémoire était dépassée. En effet, notre microcontrôleur ATMega16u2 n'a que 2k de mémoire.		Pour la programmation de la carte électronique RNDIS, nous avons utilisé une démonstration LUFA déjà existante qui implémente une pile TCP/IP. En faisant directement un "make", nous avons remarqué que l'espace mémoire était dépassée. En effet, notre microcontrôleur ATMega16u2 n'a que 2k de mémoire.

Acegarra : Mise en page générale

2023-12-28T17:53:11Z

Mise en page générale

← Version précédente		Version du 28 décembre 2023 à 17:53
Ligne 16 :		Ligne 16 :
	== Ordonnanceur ==		== Ordonnanceur ==

	=== 1) Clignotement de 2 LEDs ===		=== Clignotement de 2 LEDs ===
	Nous avons commencé l'ordonnanceur avec l'objectif de faire clignoter dans un premier temps 2 LEDs, à l'aide de deux tâches statiques, avec des périodes différentes.		Nous avons commencé l'ordonnanceur avec l'objectif de faire clignoter dans un premier temps 2 LEDs, à l'aide de deux tâches statiques, avec des périodes différentes.

Ligne 55 :		Ligne 55 :
	[[Fichier:Clignotement des LEDs grâce à l'ordonnanceur.mov\|alt=Clignotement des LEDs grâce à l'ordonnanceur\|vignette\|Clignotement des LEDs grâce à l'ordonnanceur\|centré]]		[[Fichier:Clignotement des LEDs grâce à l'ordonnanceur.mov\|alt=Clignotement des LEDs grâce à l'ordonnanceur\|vignette\|Clignotement des LEDs grâce à l'ordonnanceur\|centré]]

	=== 2) Ecriture de caractères sur le port série ===		=== Ecriture de caractères sur le port série ===
	Tout d'abord, avant de commencer la tâche, nous savions que nous devions utiliser l'UART du microcontrôleur. De plus, la tâche suivante devait utiliser aussi l'UART. Puisque 2 tâches utilisent la même ressource, il faut implémenter un système pour savoir quelle tâche utilise la ressource. Nous avons alors utilisé une sémaphore pour chaque tâche, permettant ainsi de limiter l'accès temporairement à la ressources aux autres tâches : <syntaxhighlight lang="c">		Tout d'abord, avant de commencer la tâche, nous savions que nous devions utiliser l'UART du microcontrôleur. De plus, la tâche suivante devait utiliser aussi l'UART. Puisque 2 tâches utilisent la même ressource, il faut implémenter un système pour savoir quelle tâche utilise la ressource. Nous avons alors utilisé une sémaphore pour chaque tâche, permettant ainsi de limiter l'accès temporairement à la ressources aux autres tâches : <syntaxhighlight lang="c">
	void semaphore_write(int action){		void semaphore_write(int action){
Ligne 109 :		Ligne 109 :
	</syntaxhighlight>On peut observer que la tâche fonctionne comme sur la vidéo suivante :[[Fichier:Tâche d'écriture sur le port série.mp4\|vignette\|Tâche d'écriture sur le port série\|centré]]		</syntaxhighlight>On peut observer que la tâche fonctionne comme sur la vidéo suivante :[[Fichier:Tâche d'écriture sur le port série.mp4\|vignette\|Tâche d'écriture sur le port série\|centré]]

	=== 3) Lecture sur le port série ===		=== Lecture sur le port série ===
	De la même façon que la tâche précédente, pour cette tâche nous devons lire les pressions de touches du clavier et les afficher sur le minicom. L'initialisation est déjà effectuée et la sémaphore et la même que dans la partie précédente, nous ne la traiterons donc pas. On utilise alors les fonctions suivantes pour lire les pressions des touches sur le clavier, et la tâche les fait afficher ensuite : <syntaxhighlight lang="c">		De la même façon que la tâche précédente, pour cette tâche nous devons lire les pressions de touches du clavier et les afficher sur le minicom. L'initialisation est déjà effectuée et la sémaphore et la même que dans la partie précédente, nous ne la traiterons donc pas. On utilise alors les fonctions suivantes pour lire les pressions des touches sur le clavier, et la tâche les fait afficher ensuite : <syntaxhighlight lang="c">
	unsigned char serial_read(void){		unsigned char serial_read(void){
Ligne 127 :		Ligne 127 :
	[[Fichier:Tâche de lecture sur le port série.mp4\|centré\|vignette\|Tâche de lecture sur le port série]]		[[Fichier:Tâche de lecture sur le port série.mp4\|centré\|vignette\|Tâche de lecture sur le port série]]

	=== 4) Matrice de LEDs ===		=== Matrice de LEDs ===
	Dans cette partie, nous souhaitons gérer l'affichage d'une matrice de LEDs 8x8 grâce au SPI. Il faut alors réussir à initialiser le SPI correctement :<syntaxhighlight lang="c">		Dans cette partie, nous souhaitons gérer l'affichage d'une matrice de LEDs 8x8 grâce au SPI. Il faut alors réussir à initialiser le SPI correctement :<syntaxhighlight lang="c">
	void SPI_MasterInit(void){		void SPI_MasterInit(void){
Ligne 151 :		Ligne 151 :
	[[Fichier:Matrice2.mov\|centré\|vignette\|Affichage des caractères sur la matrice]]		[[Fichier:Matrice2.mov\|centré\|vignette\|Affichage des caractères sur la matrice]]

	=== 5) Afficheur 7 segments ===		=== Afficheur 7 segments ===
	Pour le 7 segments, l'initialisation est différente. En effet, le 7 segments ne fonctionne qu'à une fréquence maximale de 250kHz, il faut alors modifier l'initialisation du SPI de la tâche pour le faire fonctionner en changeant le paramètre SPCR :<syntaxhighlight lang="c">		Pour le 7 segments, l'initialisation est différente. En effet, le 7 segments ne fonctionne qu'à une fréquence maximale de 250kHz, il faut alors modifier l'initialisation du SPI de la tâche pour le faire fonctionner en changeant le paramètre SPCR :<syntaxhighlight lang="c">
	void SPI_MasterInit_segments(void){		void SPI_MasterInit_segments(void){
Ligne 164 :		Ligne 164 :
	== Carte FPGA/VHDL : ==		== Carte FPGA/VHDL : ==

	=== '''1) Contrôleur de bus série SPI''' ===		=== '''Contrôleur de bus série SPI''' ===
	Pour ce programme VHDL, nous avons voulu faire une communication SPI Maitre/Esclave. Pour cela , nous nous sommes documentés sur comment fonctionnait cette communication. Il faut alors réaliser les 4 signaux MOSI, MISO, SS et SCK afin de pouvoir communiquer. On vérifie alors chacun de bits envoyé afin de gérér les signaux de contrôle et de l'entrée MISO. Ensuite, on génère les données de sortie pour la réponse. Enfin on peut assigner les sorties avec les informations que l'on a. Voici alors les processus utilisés : <syntaxhighlight lang="vhdl">		Pour ce programme VHDL, nous avons voulu faire une communication SPI Maitre/Esclave. Pour cela , nous nous sommes documentés sur comment fonctionnait cette communication. Il faut alors réaliser les 4 signaux MOSI, MISO, SS et SCK afin de pouvoir communiquer. On vérifie alors chacun de bits envoyé afin de gérér les signaux de contrôle et de l'entrée MISO. Ensuite, on génère les données de sortie pour la réponse. Enfin on peut assigner les sorties avec les informations que l'on a. Voici alors les processus utilisés : <syntaxhighlight lang="vhdl">
	-- Processus 1 : Gestion des signaux de contrôle et de l'entrée MISO		-- Processus 1 : Gestion des signaux de contrôle et de l'entrée MISO
Ligne 216 :		Ligne 216 :
	</syntaxhighlight>		</syntaxhighlight>

	=== '''2) Contrôleur VGA''' ===		=== '''Contrôleur VGA''' ===
	Pour ce contrôleur, il faut utiliser le port VGA présent sur la carte Basys-3. Sur ce connecteur VGA, il y a plusieurs sorties à gérer. En effet, il y a les signaux de synchronisation HS et VS qui fonctionnent si ils ont une certaines formes d'ondes. Ces signaux doivent être à 0 pendant un certain temps. De plus, nous avons les ports permettant de gérer les couleur, vert, bleu et rouge, chacun sur 4 bits. L'horloge du FPGA fonctionnant à 100MHz, nous devons la moduler à 60Hz, car l'écran fonctionne à cette fréquence. Pour cela, nous avons utilisé les IP catalogs. Ce sont des composants existants dans des librairies qui peuvent être utilisés. Dans notre cas, nous avons utilisé un composant qui permet de modifier la fréquence d’un signal.		Pour ce contrôleur, il faut utiliser le port VGA présent sur la carte Basys-3. Sur ce connecteur VGA, il y a plusieurs sorties à gérer. En effet, il y a les signaux de synchronisation HS et VS qui fonctionnent si ils ont une certaines formes d'ondes. Ces signaux doivent être à 0 pendant un certain temps. De plus, nous avons les ports permettant de gérer les couleur, vert, bleu et rouge, chacun sur 4 bits. L'horloge du FPGA fonctionnant à 100MHz, nous devons la moduler à 60Hz, car l'écran fonctionne à cette fréquence. Pour cela, nous avons utilisé les IP catalogs. Ce sont des composants existants dans des librairies qui peuvent être utilisés. Dans notre cas, nous avons utilisé un composant qui permet de modifier la fréquence d’un signal.

Ligne 286 :		Ligne 286 :
	== Carte fille réseau RNDIS : ==		== Carte fille réseau RNDIS : ==

	=== 1) Création de la carte électronique RNDIS ===		=== Création de la carte électronique RNDIS ===
	Nous avons choisi de réaliser la carte réseau RNDIS car nous pensons que ce projet était aussi en lien avec nos cours de réseau et de système d'exploitation, cette carte était pour nous un moyen d'en apprendre plus sur ces aspects.		Nous avons choisi de réaliser la carte réseau RNDIS car nous pensons que ce projet était aussi en lien avec nos cours de réseau et de système d'exploitation, cette carte était pour nous un moyen d'en apprendre plus sur ces aspects.

Ligne 306 :		Ligne 306 :
	Nous avons alors routé notre carte, il fallait donc faire un fichier ZIP à partir de ces fichiers afin que la carte puisse être envoyée en production pour que l'on puisse souder les composants par la suite. Nous avons donc suivi les étapes de ce tutoriel : ''https://jlcpcb.com/help/article/16-How-to-generate-Gerber-and-Drill-files-in-KiCad-6''.		Nous avons alors routé notre carte, il fallait donc faire un fichier ZIP à partir de ces fichiers afin que la carte puisse être envoyée en production pour que l'on puisse souder les composants par la suite. Nous avons donc suivi les étapes de ce tutoriel : ''https://jlcpcb.com/help/article/16-How-to-generate-Gerber-and-Drill-files-in-KiCad-6''.

	=== 2) Soudure de la carte électronique RNDIS ===		=== Soudure de la carte électronique RNDIS ===
	Durant deux séances, nous avons réalisé la soudure de la carte électronique sur laquelle nous avons été aidés pour souder le quartz ainsi que le port USB. A noter que sur la carte, deux diodes ont été enlevées au niveau de l'USB car il était impossible de la reconnaître par notre machine grâce à la commande ''"lsusb".'' Hormis les diodes à enlever, aucune difficulté n'a été relevée durant la soudure de la carte.		Durant deux séances, nous avons réalisé la soudure de la carte électronique sur laquelle nous avons été aidés pour souder le quartz ainsi que le port USB. A noter que sur la carte, deux diodes ont été enlevées au niveau de l'USB car il était impossible de la reconnaître par notre machine grâce à la commande ''"lsusb".'' Hormis les diodes à enlever, aucune difficulté n'a été relevée durant la soudure de la carte.

Ligne 321 :		Ligne 321 :
	Après cela, nous allons entamé la programmation pour avoir une communication RNDIS.		Après cela, nous allons entamé la programmation pour avoir une communication RNDIS.

	=== '''3) Programmation de la carte électronique RNDIS''' ===		=== '''Programmation de la carte électronique RNDIS''' ===
	Pour la programmation de la carte électronique RNDIS, nous avons utilisé une démonstration LUFA déjà existante qui implémente une pile TCP/IP. En faisant directement un "make", nous avons remarqué que l'espace mémoire était dépassée. En effet, notre microcontrôleur ATMega16u2 n'a que 2k de mémoire.		Pour la programmation de la carte électronique RNDIS, nous avons utilisé une démonstration LUFA déjà existante qui implémente une pile TCP/IP. En faisant directement un "make", nous avons remarqué que l'espace mémoire était dépassée. En effet, notre microcontrôleur ATMega16u2 n'a que 2k de mémoire.

Acegarra : correction orthographique

2023-12-28T17:51:11Z

correction orthographique

← Version précédente		Version du 28 décembre 2023 à 17:51
Ligne 56 :		Ligne 56 :

	=== 2) Ecriture de caractères sur le port série ===		=== 2) Ecriture de caractères sur le port série ===
	Tout d'abord, avant de commencer la tâche, nous savions que nous devions utiliser l'UART du microcontrôleur. De plus, la tâche suivante devait utiliser aussi l'UART. Puisque 2 tâches utilisent la même ressource, il faut implémenter un système pour savoir quelle tâche utilise la ressource. Nous avons alors ~~utiliser~~ une sémaphore pour chaque tâche, permettant ainsi de limiter l'accès temporairement à la ressources aux autres tâches : <syntaxhighlight lang="c">		Tout d'abord, avant de commencer la tâche, nous savions que nous devions utiliser l'UART du microcontrôleur. De plus, la tâche suivante devait utiliser aussi l'UART. Puisque 2 tâches utilisent la même ressource, il faut implémenter un système pour savoir quelle tâche utilise la ressource. Nous avons alors utilisé une sémaphore pour chaque tâche, permettant ainsi de limiter l'accès temporairement à la ressources aux autres tâches : <syntaxhighlight lang="c">
	void semaphore_write(int action){		void semaphore_write(int action){
	if(action == TAKE_RESOURCE){		if(action == TAKE_RESOURCE){

Acegarra : correction orthographique

2023-12-28T17:49:45Z

correction orthographique

Acegarra : correction orthographique

2023-12-28T17:45:29Z

correction orthographique

← Version précédente		Version du 28 décembre 2023 à 17:45
Ligne 377 :		Ligne 377 :
	</syntaxhighlight>De cette façon, lorsqu'une trame respectant notre forme et utilisant notre protocole est envoyé sur l'interface, la LED de la carte devrait clignoter.		</syntaxhighlight>De cette façon, lorsqu'une trame respectant notre forme et utilisant notre protocole est envoyé sur l'interface, la LED de la carte devrait clignoter.

	Enfin, il faut aussi adapter le fichier "ProtocolsDecoders" afin que la LUFA ~~arraive~~ à décoder notre trame : <syntaxhighlight lang="c">		Enfin, il faut aussi adapter le fichier "ProtocolsDecoders" afin que la LUFA arrive à décoder notre trame : <syntaxhighlight lang="c">
	void DecodePICOFrameHeader(void* InDataStart)		void DecodePICOFrameHeader(void* InDataStart)
	{		{
Ligne 421 :		Ligne 421 :


	Cependant, on remarque que la LED s'allume, c'est-à-dire que la réponse est bien créée, mais elle n'est pas envoyée. En remontant chaque fonction pouvant être la cause du non-envoi de la réponse, nous avons "RNDIS_Task" que nous n'arrivons pas à comprendre. Cependant, nous n'avons pas modifié cette fonction, cela doit ~~venir~~ de la trame envoyée, mais pourtant le programme rentre bien complétement dans la fonction. A ce stade nous n'arrivons toujours pas à trouver la cause du problème.		Cependant, on remarque que la LED s'allume, c'est-à-dire que la réponse est bien créée, mais elle n'est pas envoyée. En remontant chaque fonction pouvant être la cause du non-envoi de la réponse, nous avons "RNDIS_Task" que nous n'arrivons pas à comprendre. Cependant, nous n'avons pas modifié cette fonction, cela doit provenir de la trame envoyée, mais pourtant le programme rentre bien complétement dans la fonction. A ce stade nous n'arrivons toujours pas à trouver la cause du problème.

	== Rendus : ==		== Rendus : ==
	Lien de notre GIT : https://archives.plil.fr/ncazin/Projet_Pico_SE4.git		Lien de notre GIT : https://archives.plil.fr/ncazin/Projet_Pico_SE4.git

Acegarra : correction orthographique

2023-12-28T17:42:28Z

correction orthographique

← Version précédente		Version du 28 décembre 2023 à 17:42
Ligne 333 :		Ligne 333 :
	[[Fichier:Reception .mp4\|centré\|vignette\|Réception de paquets IP ]]A ce moment précis, la carte allume bien les LEDs lors de la récéption des mêmes paquets que ceux implémentés dans la pile TCP/IP. Puisque l'on veut utiliser nos propres paquets avec notre protocole, nous devons ajouter dans cette pile le traitement de notre protocole.		[[Fichier:Reception .mp4\|centré\|vignette\|Réception de paquets IP ]]A ce moment précis, la carte allume bien les LEDs lors de la récéption des mêmes paquets que ceux implémentés dans la pile TCP/IP. Puisque l'on veut utiliser nos propres paquets avec notre protocole, nous devons ajouter dans cette pile le traitement de notre protocole.

	Tout d'abord, dans le fichier "EthernerProtocols.h", nous avons ~~créer~~ notre protocole~~. Le notre~~ sera "0x0903"<syntaxhighlight lang="c">		Tout d'abord, dans le fichier "EthernerProtocols.h", nous avons créé notre propre protocole et sera le suivant : "0x0903"<syntaxhighlight lang="c">
	#define ETHERTYPE_PICO 0x0903		#define ETHERTYPE_PICO 0x0903
	</syntaxhighlight>Ensuite, il faut créer une structure représentant notre trame dans un fichier permettant son traitement. Ici, e fichier s'appelle "PICO.h". Nous avons alors choisi d'utiliser cette structure de trame : <syntaxhighlight lang="c">		</syntaxhighlight>Ensuite, il faut créer une structure représentant notre trame dans un fichier permettant son traitement. Ici, le fichier s'appelle "PICO.h". Nous avons alors choisi d'utiliser cette structure de trame : <syntaxhighlight lang="c">
	/** Type define for a PICO header. */		/** Type define for a PICO header. */
	typedef struct		typedef struct

Acegarra : correction orthographique

2023-12-28T17:28:30Z

correction orthographique

Ncazin : /* Carte FPGA/VHDL : */

2023-12-28T13:12:38Z

Carte FPGA/VHDL :

← Version précédente		Version du 28 décembre 2023 à 13:12
Ligne 163 :		Ligne 163 :

	== Carte FPGA/VHDL : ==		== Carte FPGA/VHDL : ==
	'''~~<big>~~1) Contrôleur de bus série SPI~~</big>~~'''
			=== '''1) Contrôleur de bus série SPI''' ===


	Pour ce programme VHDL, nous avons voulu faire une communication SPI Maitre - Esclave. Pour cela =, nous nous sommes documentés sur comment fonctionnait cette communication. Il faut alors réaliser les 4 signaux MOSI, MISO, SS et SCK afin de pouvoir communiquer. On vérifie alors chacun de bits envoyé afin de gérér les signaux de contrôle et de l'entrée MISO. Ensuite, on génère les données de sortie pour la réponse. Enfin on peut assigner les sorties avec les informations que l'on a. Voici alors les processus utilisés : <syntaxhighlight lang="vhdl">		Pour ce programme VHDL, nous avons voulu faire une communication SPI Maitre - Esclave. Pour cela =, nous nous sommes documentés sur comment fonctionnait cette communication. Il faut alors réaliser les 4 signaux MOSI, MISO, SS et SCK afin de pouvoir communiquer. On vérifie alors chacun de bits envoyé afin de gérér les signaux de contrôle et de l'entrée MISO. Ensuite, on génère les données de sortie pour la réponse. Enfin on peut assigner les sorties avec les informations que l'on a. Voici alors les processus utilisés : <syntaxhighlight lang="vhdl">
Ligne 214 :		Ligne 216 :
	MOSI <= data_out(7);		MOSI <= data_out(7);
	data_in <= received_data;		data_in <= received_data;
	</syntaxhighlight>~~'''<big>2) Contrôleur VGA</big>'''~~		</syntaxhighlight>

			=== '''2) Contrôleur VGA''' ===
	Pour ce contrôleur, il faut utiliser le port VGA présent sur la carte Basys-3. Sur ce connecteur VGA, il y a plusieurs sorties à gérer. En effet, il y a les signaux de synchronisation HS et VS qui fonctionnent si ils ont une certaines formes d'ondes. Ces signaux doivent être à 0 pendant un certain temps. De plus nous avons les ports permettant de gérer les couleur, vert, bleu et rouge, chacun sur 4 bits. L'horloge du FPGA fonctionnant à 100MHz, nous devons la moduler à 60Hz, car l'écran fonctionne à cette fréquence. Pour cela, nous avons utilisé les IP catalogs. Ce sont des composants existants dans des librairies qui peuvent être utilisés. Dans notre cas, nous avons utilisé un composant qui permet de modifier la fréquence d’un signal.		Pour ce contrôleur, il faut utiliser le port VGA présent sur la carte Basys-3. Sur ce connecteur VGA, il y a plusieurs sorties à gérer. En effet, il y a les signaux de synchronisation HS et VS qui fonctionnent si ils ont une certaines formes d'ondes. Ces signaux doivent être à 0 pendant un certain temps. De plus nous avons les ports permettant de gérer les couleur, vert, bleu et rouge, chacun sur 4 bits. L'horloge du FPGA fonctionnant à 100MHz, nous devons la moduler à 60Hz, car l'écran fonctionne à cette fréquence. Pour cela, nous avons utilisé les IP catalogs. Ce sont des composants existants dans des librairies qui peuvent être utilisés. Dans notre cas, nous avons utilisé un composant qui permet de modifier la fréquence d’un signal.

← Version précédente		Version du 28 décembre 2023 à 17:49
Ligne 56 :		Ligne 56 :

	=== 2) Ecriture de caractères sur le port série ===		=== 2) Ecriture de caractères sur le port série ===
	Tout d'abord, avant de commencer la tâche, nous savions que nous devions utiliser l'UART du ~~microcontrolleur~~. De plus, la tâche suivante devait utiliser aussi l'UART. Puisque 2 tâches utilisent la même ressource, il faut implémenter un système pour savoir quelle tâche utilise la ressource. Nous avons alors utiliser une sémaphore pour chaque tâche, permettant ainsi de limiter l'accès temporairement à la ressources aux autres tâches : <syntaxhighlight lang="c">		Tout d'abord, avant de commencer la tâche, nous savions que nous devions utiliser l'UART du microcontrôleur. De plus, la tâche suivante devait utiliser aussi l'UART. Puisque 2 tâches utilisent la même ressource, il faut implémenter un système pour savoir quelle tâche utilise la ressource. Nous avons alors utiliser une sémaphore pour chaque tâche, permettant ainsi de limiter l'accès temporairement à la ressources aux autres tâches : <syntaxhighlight lang="c">
	void semaphore_write(int action){		void semaphore_write(int action){
	if(action == TAKE_RESOURCE){		if(action == TAKE_RESOURCE){
Ligne 86 :		Ligne 86 :
	}		}
	}		}
	</syntaxhighlight>Après avoir implémenté cette sémaphore, il fallait que nous comprenions comment utiliser l'UART du ~~microcontrôlleur~~. Pour cela, il faut initialiser correctement l'UART pour pouvoir écrire et lire en série. La fonction suivante permet d'initialiser correctement l'UART : <syntaxhighlight lang="c">		</syntaxhighlight>Après avoir implémenté cette sémaphore, il fallait que nous comprenions comment utiliser l'UART du microcontrôleur. Pour cela, il faut initialiser correctement l'UART pour pouvoir écrire et lire en série. La fonction suivante permet d'initialiser correctement l'UART : <syntaxhighlight lang="c">
	void init_usart(long int speed){		void init_usart(long int speed){
	UBRR0 = FREQUENCE/((unsigned long int)speed << 4) -1;		UBRR0 = FREQUENCE/((unsigned long int)speed << 4) -1;
Ligne 110 :		Ligne 110 :

	=== 3) Lecture sur le port série ===		=== 3) Lecture sur le port série ===
	De la même façon que la tâche précédente, pour cette tâche nous devons lire les pressions de touches du clavier et les afficher sur le minicom. L'initialisation est déjà ~~efféctuée~~ et la sémaphore et la même que dans la partie précédente, nous ne la traiterons donc pas. On utilise alors les fonctions suivantes pour lire les pressions des touches sur le clavier, et la tâche les fait afficher ensuite : <syntaxhighlight lang="c">		De la même façon que la tâche précédente, pour cette tâche nous devons lire les pressions de touches du clavier et les afficher sur le minicom. L'initialisation est déjà effectuée et la sémaphore et la même que dans la partie précédente, nous ne la traiterons donc pas. On utilise alors les fonctions suivantes pour lire les pressions des touches sur le clavier, et la tâche les fait afficher ensuite : <syntaxhighlight lang="c">
	unsigned char serial_read(void){		unsigned char serial_read(void){
	loop_until_bit_is_set(UCSR0A, RXC0);		loop_until_bit_is_set(UCSR0A, RXC0);
Ligne 134 :		Ligne 134 :
	SPCR = (1 << SPE) \| (1 << MSTR) \| (1 << SPR0);		SPCR = (1 << SPE) \| (1 << MSTR) \| (1 << SPR0);
	}		}
	</syntaxhighlight>Ensuite, nous avons ~~rédiger~~ un programme utilisé par notre tâche afin d'afficher différents caractères sur la matrice en allumant les LEDs voulues bit par bit :<syntaxhighlight lang="c">		</syntaxhighlight>Ensuite, nous avons rédigé un programme utilisé par notre tâche afin d'afficher différents caractères sur la matrice en allumant les LEDs voulues bit par bit :<syntaxhighlight lang="c">
	void loop_matrix(char letter[8]){		void loop_matrix(char letter[8]){
	int temp;		int temp;

← Version précédente		Version du 28 décembre 2023 à 17:28
Ligne 165 :		Ligne 165 :

	=== '''1) Contrôleur de bus série SPI''' ===		=== '''1) Contrôleur de bus série SPI''' ===
			Pour ce programme VHDL, nous avons voulu faire une communication SPI Maitre/Esclave. Pour cela , nous nous sommes documentés sur comment fonctionnait cette communication. Il faut alors réaliser les 4 signaux MOSI, MISO, SS et SCK afin de pouvoir communiquer. On vérifie alors chacun de bits envoyé afin de gérér les signaux de contrôle et de l'entrée MISO. Ensuite, on génère les données de sortie pour la réponse. Enfin on peut assigner les sorties avec les informations que l'on a. Voici alors les processus utilisés : <syntaxhighlight lang="vhdl">

	Pour ce programme VHDL, nous avons voulu faire une communication SPI Maitre - Esclave. Pour cela =, nous nous sommes documentés sur comment fonctionnait cette communication. Il faut alors réaliser les 4 signaux MOSI, MISO, SS et SCK afin de pouvoir communiquer. On vérifie alors chacun de bits envoyé afin de gérér les signaux de contrôle et de l'entrée MISO. Ensuite, on génère les données de sortie pour la réponse. Enfin on peut assigner les sorties avec les informations que l'on a. Voici alors les processus utilisés : <syntaxhighlight lang="vhdl">
	-- Processus 1 : Gestion des signaux de contrôle et de l'entrée MISO		-- Processus 1 : Gestion des signaux de contrôle et de l'entrée MISO
	process (reset, start_transfer, MISO)		process (reset, start_transfer, MISO)
Ligne 219 :		Ligne 217 :

	=== '''2) Contrôleur VGA''' ===		=== '''2) Contrôleur VGA''' ===
	Pour ce contrôleur, il faut utiliser le port VGA présent sur la carte Basys-3. Sur ce connecteur VGA, il y a plusieurs sorties à gérer. En effet, il y a les signaux de synchronisation HS et VS qui fonctionnent si ils ont une certaines formes d'ondes. Ces signaux doivent être à 0 pendant un certain temps. De plus nous avons les ports permettant de gérer les couleur, vert, bleu et rouge, chacun sur 4 bits. L'horloge du FPGA fonctionnant à 100MHz, nous devons la moduler à 60Hz, car l'écran fonctionne à cette fréquence. Pour cela, nous avons utilisé les IP catalogs. Ce sont des composants existants dans des librairies qui peuvent être utilisés. Dans notre cas, nous avons utilisé un composant qui permet de modifier la fréquence d’un signal.		Pour ce contrôleur, il faut utiliser le port VGA présent sur la carte Basys-3. Sur ce connecteur VGA, il y a plusieurs sorties à gérer. En effet, il y a les signaux de synchronisation HS et VS qui fonctionnent si ils ont une certaines formes d'ondes. Ces signaux doivent être à 0 pendant un certain temps. De plus, nous avons les ports permettant de gérer les couleur, vert, bleu et rouge, chacun sur 4 bits. L'horloge du FPGA fonctionnant à 100MHz, nous devons la moduler à 60Hz, car l'écran fonctionne à cette fréquence. Pour cela, nous avons utilisé les IP catalogs. Ce sont des composants existants dans des librairies qui peuvent être utilisés. Dans notre cas, nous avons utilisé un composant qui permet de modifier la fréquence d’un signal.

	Nous avons ensuite reconstitué le signal de HS et VS. En effet, ces signaux ont besoin d’une période très spécifique permettant de bien configurer la taille de notre écran. Nous avons donc configuré un compteur incrémenté à chaque front montant de l’horloge, ce qui permet de mettre à l’état bas nos signaux.		Nous avons ensuite reconstitué le signal de HS et VS. En effet, ces signaux ont besoin d’une période très spécifique permettant de bien configurer la taille de notre écran. Nous avons donc configuré un compteur incrémenté à chaque front montant de l’horloge, ce qui permet de mettre à l’état bas nos signaux.
Ligne 302 :		Ligne 300 :
	De cette façon, nous pouvons récupérer et envoyer simplement des informations depuis la carte mère. Nous avons aussi connecté des LEDs sur les ports PC4 à PC7. Les autres ports sont connectés à des testpoints. La communication RNDIS se faisant via le port USB, nous avons aussi implémenter un port USB communicant via D+ et D-. Par sécurité, nous avons aussi mis un AVR-ISP dans le cas où la programmation du microcontrôleur se fasse pas correctement. Voici alors le schéma électrique de notre carte RNDIS :		De cette façon, nous pouvons récupérer et envoyer simplement des informations depuis la carte mère. Nous avons aussi connecté des LEDs sur les ports PC4 à PC7. Les autres ports sont connectés à des testpoints. La communication RNDIS se faisant via le port USB, nous avons aussi implémenter un port USB communicant via D+ et D-. Par sécurité, nous avons aussi mis un AVR-ISP dans le cas où la programmation du microcontrôleur se fasse pas correctement. Voici alors le schéma électrique de notre carte RNDIS :
	[[Fichier:Schéma électrique de la carte RNDIS.jpg\|alt=Schéma électrique de la carte RNDIS\|centré\|vignette\|234x234px\|Schéma électrique de la carte RNDIS]]		[[Fichier:Schéma électrique de la carte RNDIS.jpg\|alt=Schéma électrique de la carte RNDIS\|centré\|vignette\|234x234px\|Schéma électrique de la carte RNDIS]]
	Après avoir réalisé le schéma électrique, nous avons fait le routage de la carte. Le routage était simple, nous avons commencé par router les parties USB et microcontôleur car nous savons comment elles doivent êtres disposées. Le plus difficile dans ce routage a été de mettre le capacités les plus proches du quartz et du microcontôleur car nous avons essayé de faire une carte compacte, et les testpoints prennent beaucoup de place sur la carte. Il fallait donc être précis sur la disposition des composants. Il fallait aussi faire attention à ce que les pistes D+ et D- soient les plus courtes et avec le moins de via possibles pour ne pas endommager les signaux que l'on souhaite envoyer. Nous avons fait le plan de masse de la carte et au final nous avons réussi à compacter la carte pour qu'elle fasse une taille de 33mm ~~x 43mm~~. Voici alors le routage de notre carte RNDIS.		Après avoir réalisé le schéma électrique, nous avons fait le routage de la carte. Le routage était simple, nous avons commencé par router les parties USB et microcontôleur car nous savons comment elles doivent êtres disposées. Le plus difficile dans ce routage a été de mettre le capacités les plus proches du quartz et du microcontôleur car nous avons essayé de faire une carte compacte, et les testpoints prennent beaucoup de place sur la carte. Il fallait donc être précis sur la disposition des composants. Il fallait aussi faire attention à ce que les pistes D+ et D- soient les plus courtes et avec le moins de via possibles pour ne pas endommager les signaux que l'on souhaite envoyer. Nous avons fait le plan de masse de la carte et au final, nous avons réussi à compacter la carte pour qu'elle fasse une taille de 43mm par 33mm. Voici alors le routage de notre carte RNDIS.
	[[Fichier:Routage de la carte RNDIS.jpg\|alt=Routage de la carte RNDIS\|centré\|vignette\|245x245px\|Routage de la carte RNDIS]]		[[Fichier:Routage de la carte RNDIS.jpg\|alt=Routage de la carte RNDIS\|centré\|vignette\|245x245px\|Routage de la carte RNDIS]]
	Voici donc une réprésentation 3D de notre carte RNDIS :		Voici donc une réprésentation 3D de notre carte RNDIS :
Ligne 333 :		Ligne 331 :
	[[Fichier:Ping usb0 2.png\|alt=Ping vers la carte RNDIS\|centré\|vignette\|Ping vers la carte RNDIS]]		[[Fichier:Ping usb0 2.png\|alt=Ping vers la carte RNDIS\|centré\|vignette\|Ping vers la carte RNDIS]]
	Il faut maintenant recevoir les paquets envoyés et vérifiés leur bonne réception sur le terminal. Nous avons alors utiliser l'outil "ether" afin d'observer les paquets reçues sur l'interface "usb0" créée. Pour rendre compte des paquets envoyés/reçus, nous allumons une LED à chaque ping :		Il faut maintenant recevoir les paquets envoyés et vérifiés leur bonne réception sur le terminal. Nous avons alors utiliser l'outil "ether" afin d'observer les paquets reçues sur l'interface "usb0" créée. Pour rendre compte des paquets envoyés/reçus, nous allumons une LED à chaque ping :
	[[Fichier:Reception .mp4\|centré\|vignette\|Réception de paquets IP ]]A ce moment~~-là~~, la carte allume bien les LEDs lors de la récéption des mêmes paquets que ceux implémentés dans la pile TCP/IP. Puisque l'on veut utiliser nos propres paquets avec notre protocole, nous devons ajouter dans cette pile le traitement de notre protocole.		[[Fichier:Reception .mp4\|centré\|vignette\|Réception de paquets IP ]]A ce moment précis, la carte allume bien les LEDs lors de la récéption des mêmes paquets que ceux implémentés dans la pile TCP/IP. Puisque l'on veut utiliser nos propres paquets avec notre protocole, nous devons ajouter dans cette pile le traitement de notre protocole.

	Tout d'abord, dans le fichier "EthernerProtocols.h", nous avons créer notre protocole. Le notre sera "0x0903"<syntaxhighlight lang="c">		Tout d'abord, dans le fichier "EthernerProtocols.h", nous avons créer notre protocole. Le notre sera "0x0903"<syntaxhighlight lang="c">

SE4Binome2023-8 - Historique des versions

Ncazin : /* Matériel : */

Ncazin : /* Matériel : */

Acegarra : Mise en page générale

Acegarra : Mise en page générale

Acegarra : correction orthographique

Acegarra : correction orthographique

Acegarra : correction orthographique

Acegarra : correction orthographique

Acegarra : correction orthographique

Ncazin : /* Carte FPGA/VHDL : */

Ncazin : /* Matériel : */

Ncazin : /* Matériel : */

Acegarra : Mise en page générale

Acegarra : Mise en page générale

Acegarra : correction orthographique

Acegarra : correction orthographique

Acegarra : correction orthographique

Acegarra : correction orthographique

Acegarra : correction orthographique

Ncazin : /* Carte FPGA/VHDL : */