SE3Trinome2022-8 - Historique des versions

Ncazin : modif et correction

2023-09-04T16:31:44Z

modif et correction

Ncazin : /* Connexion de la carte sur ordinateur : */

2023-09-04T08:33:16Z

Connexion de la carte sur ordinateur :

← Version précédente		Version du 4 septembre 2023 à 08:33
Ligne 104 :		Ligne 104 :
	[[Fichier:Carte moteur pap.jpg\|alt=Carte avec le moteur pas-à-pas soudé\|centré\|vignette\|Carte avec le moteur pas-à-pas soudé]]		[[Fichier:Carte moteur pap.jpg\|alt=Carte avec le moteur pas-à-pas soudé\|centré\|vignette\|Carte avec le moteur pas-à-pas soudé]]

	== ~~Connexion~~ de la carte sur ordinateur : ==		== Problèmes eu pendant la programmation de la carte sur ordinateur : ==
	~~Avant~~ de ~~commencer~~ la programmation~~, j’ai voulu voir si~~ la carte était toujours détectée grâce à la commande shell « '''''lsusb''''' » afin de savoir si le microcontrôleur n’avait pas lui aussi eu un problème pendant le voyage. J’ai alors rencontré plusieurs problèmes.		J'ai rencontré plusieurs problèmes lors de la programmation de mes programmes et lors de la reconnaissance de la carte par les machines.

	~~En effet~~, ~~j’avais~~ commencé à développer mes programmes informatiques sur les machines de l’école à distance grâce à l’outil : '''https://tp-info.polytech-lille.fr/#''' ~~. J’ai donc voulu voir si la carte était reconnue aussi depuis les machines à distances.~~		Tout d'abord, il faut savoir que j'ai commencé développer mes programmes informatiques sur les machines de l’école à distance grâce à l’outil : '''https://tp-info.polytech-lille.fr/#'''

	Cependant, lorsque je me connecte sur ces machines, les périphériques USB de mon ordinateur ne sont pas reconnus. En faisant plusieurs essais pour résoudre ce problème, j’ai compris que ce n’était pas possible et donc qu’il fallait passer par une autre méthode. Sois-je faisais directement la programmation sur Windows mais télécharger les dépendances et le compilateur C allait être compliqué. Sois-je téléchargeais une machine virtuelle Ubuntu pour être directement sur un système Linux et plus simplement programmer. J’ai donc choisi la première option car je craignais que la machine virtuelle ne reconnaisse pas elle aussi les périphériques USB.		Ensuite, le premier problème était que certaines bibliothèques utilisées, notamment '''''<avr/io.h>''''' ne sont pas trouvables, ce qui fait que la compilation d'un de mes fichiers de test ne peut pas être réalisée. J'ai comme hypothèse que soit la librairie n'est pas installée sur les machines des salles de TP en C10X, soit il faut être en superutilisateur pour pouvoir compiler le fichier d'après les notes que j'avais des cours. Je ne peux pas me mettre en superutilisateur car il faut le mot de passe de la machine locale que je ne connais pas. Pour contourner ce problème, j'ai défini comme constantes toutes les variables utilisées mais ce n'est qu'une solution temporaire qui ne marchera peut-être pas lors de l'envoi du programme sur la carte, mais au moins j'ai réussi à compiler mes fichiers.
			[[Fichier:Erreur include.jpg\|alt=Message de l'erreur reçu par rapport à la librairie <avr/io.h>\|centré\|vignette\|Message de l'erreur reçu par rapport à la librairie <avr/io.h>]]


			Enfin, pour le second problème, j’ai voulu voir si la carte était reconnue depuis les machines à distance grâce à la commande shell « '''''lsusb''''' ». Cependant, lorsque je me connecte sur ces machines, les périphériques USB de mon ordinateur ne sont pas reconnus. En faisant plusieurs essais pour résoudre ce problème, j’ai compris que ce n’était pas possible et donc qu’il fallait passer par une autre méthode. Sois-je faisais directement la programmation sur Windows mais télécharger les dépendances et le compilateur C allait être compliqué. Sois-je téléchargeais une machine virtuelle Ubuntu pour être directement sur un système Linux et plus simplement programmer. J’ai donc choisi la première option car je craignais que la machine virtuelle ne reconnaisse pas elle aussi les périphériques USB.

	J’ai donc modifié l’option développeur de mon Windows afin de pouvoir télécharger un environnement terminal Ubuntu qui fonctionne grâce à Windows Subsystem for Linux (WSL). J’ai alors rencontré une erreur lors du lancement du terminal Ubuntu :		J’ai donc modifié l’option développeur de mon Windows afin de pouvoir télécharger un environnement terminal Ubuntu qui fonctionne grâce à Windows Subsystem for Linux (WSL). J’ai alors rencontré une erreur lors du lancement du terminal Ubuntu :
Ligne 116 :		Ligne 120 :
	[[Fichier:Erreur libusb.jpg\|alt=Erreur de la libusb sur Ubuntu\|centré\|vignette\|Erreur de la libusb sur Ubuntu]]		[[Fichier:Erreur libusb.jpg\|alt=Erreur de la libusb sur Ubuntu\|centré\|vignette\|Erreur de la libusb sur Ubuntu]]
	J’ai donc télécharger la librairie libusb grâce à la commande « '''''sudo apt-get install libusb-1.0-0-dev''''' » que j’ai trouver grâce aux informations de ce site : '''https://askubuntu.com/questions/629619/how-to-install-libusb''' mais même en faisant cette commande, j’ai toujours eu la même erreur. Donc à ce stade du projet, je ne peux donc pas transférer et tester mes programmes, je vais continuer à chercher une solution.		J’ai donc télécharger la librairie libusb grâce à la commande « '''''sudo apt-get install libusb-1.0-0-dev''''' » que j’ai trouver grâce aux informations de ce site : '''https://askubuntu.com/questions/629619/how-to-install-libusb''' mais même en faisant cette commande, j’ai toujours eu la même erreur. Donc à ce stade du projet, je ne peux donc pas transférer et tester mes programmes, je vais continuer à chercher une solution.

			En parallèle, j'ai essayé d'installer une machine virtuelle Ubuntu sur mon ordinateur, mais Oracle VM VirtualBox n'accepte que les fichiers .xml alors que je me suis procuré un fichier .iso

	== Programmation du moteur continu : ==		== Programmation du moteur continu : ==
Ligne 152 :		Ligne 158 :
	PORTD=(0<<PD0); //MOT2 à LOW		PORTD=(0<<PD0); //MOT2 à LOW
	}		}
	</syntaxhighlight>Après avoir fait cela, je me suis demander si nous pouvions contrôler la vitesse du moteur. J’ai alors regardé trouver une page d’un cours de PSE ('''https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme053.html''')expliquant comment fonctionne les actionneurs simples grâce au signaux PWM (Pulse Width Modulation). Une partie du programme pour l’initialisation des ports était donnée, cependant il s’agissait de la gestion des sorties que je ne comprenais pas (OCR0A, OCR0B …), j’ai donc dû effectuer plusieurs recherches sur cette partie.		</syntaxhighlight>Après avoir fait cela, je me suis demander si nous pouvions contrôler la vitesse du moteur. J’ai alors regardé trouver une page d’un cours de PSE ('''https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme053.html''')expliquant comment fonctionne les actionneurs simples grâce au signaux PWM (Pulse Width Modulation). Une partie du programme pour l’initialisation des ports était donnée, cependant il s’agissait de la gestion des sorties que je ne comprenais pas (OCR0A, OCR0B …), j’ai donc dû effectuer plusieurs recherches sur cette partie. Voici donc le code pour faire fonctionner le moteur de cette autre façon :<syntaxhighlight lang="c">

	~~Voici~~ donc le code pour faire fonctionner le moteur de cette autre façon :<syntaxhighlight lang="c">
	//////////////////////////////////////////		//////////////////////////////////////////
	/// INITIALISATION MOTEUR DC AVEC OCR1 ///		/// INITIALISATION MOTEUR DC AVEC OCR1 ///
Ligne 187 :		Ligne 191 :

	== Programmation du moteur pas à pas : ==		== Programmation du moteur pas à pas : ==
	Comme je n'avais jamais travaillé sur un moteur pas à pas, j'ai voulu comprendre son fonctionnement. Après plusieurs recherches, j'ai compris que le moteur était constitué d'un rotor magnétique et de bobines. Nous avons ici un moteur pas à pas bipolaire, avec 4 sorties. Le moteur fonctionne par pas succesifs comme une montre, ce qui ~~signigie~~ qu'il faut jouer avec chacune des sorties afin de faire le faire tourner pas par pas. En partant de ce principe nous pouvons programmer une fonction pour que chaque sorties soit sous tension les unes à la suite des autres.		Comme je n'avais jamais travaillé sur un moteur pas à pas, j'ai voulu comprendre son fonctionnement. Après plusieurs recherches, j'ai compris que le moteur était constitué d'un rotor magnétique et de bobines. Nous avons ici un moteur pas à pas bipolaire, avec 4 sorties. Le moteur fonctionne par pas succesifs comme une montre, ce qui signifie qu'il faut jouer avec chacune des sorties afin de faire le faire tourner pas par pas. En partant de ce principe nous pouvons programmer une fonction pour que chaque sorties soit sous tension les unes à la suite des autres.

	Voici le programme pour faire tourner le moteur pas à pas dans un sens :<syntaxhighlight lang="c">		Voici le programme pour faire tourner le moteur pas à pas dans un sens :<syntaxhighlight lang="c">
Ligne 228 :		Ligne 232 :
	}		}
	}		}
	</syntaxhighlight>Pour aller dans l'autre sens, il suffit d'inverser le sens des broches de sorties :<syntaxhighlight lang="c">		</syntaxhighlight>Pour aller dans l'autre sens, il suffit d'inverser le sens des broches des sorties :<syntaxhighlight lang="c">
	void stepper_right(void){		void stepper_right(void){
	for(int i = 0; i<=100; i++){		for(int i = 0; i<=100; i++){
Ligne 261 :		Ligne 265 :

	== Programmation de la communication Bluetooth : ==		== Programmation de la communication Bluetooth : ==
	La partie Bluetooth était un de nos objectifs du début de projet afin de contrôler la voiture à distance et grâce à une application. Pour cela, j’ai dû refaire des recherches sur le sujet afin ~~d’avancer~~. J’ai donc dû regarder la documentation de l’atmega16u2 et des cours d’autres universités pour bien comprendre. C’est alors que j’ai compris que la communication série UART permettrait de répondre à mes besoins. J’ai donc écrit une fonction qui permet l’initialisation de la communication série UART en activant la transmission (TX) et la réception (RX). Ensuite dans cette même fonction j’ai dû définir le format de la trame, elle est donc composée de 8 bits, c’est-à-dire un octet avec un bit d’arrêt.		La partie Bluetooth était un de nos objectifs du début de projet afin de contrôler la voiture à distance et grâce à une application. Pour cela, j’ai dû refaire des recherches sur le sujet afin de mieux comprendre comment je pourrai faire. J’ai donc dû regarder la documentation de l’atmega16u2 et des cours en ligne d’autres universités pour bien comprendre. C’est alors que j’ai compris que la communication série UART permettrait de répondre à mes besoins. J’ai donc écrit une fonction qui permet l’initialisation de la communication série UART en activant la transmission (TX) et la réception (RX). Ensuite dans cette même fonction j’ai dû définir le format de la trame, elle est donc composée de 8 bits, c’est-à-dire un octet avec un bit d’arrêt.

	Nous n’avons besoin que de recevoir des informations sur la communication série UART, pas d’en envoyer. C’est pour cela que j’ai donc dû faire une seconde fonction permettant de recevoir les informations de l’application sur le port RX de l’Atmega16U2.		Nous n’avons besoin que de recevoir des informations sur la communication série UART, pas d’en envoyer. C’est pour cela que j’ai donc dû faire une seconde fonction permettant de recevoir les informations de l’application sur le port RX de l’Atmega16U2.

Ncazin : /* Epreuve complémentaire CAZIN Némo */

2023-09-01T13:41:40Z

Epreuve complémentaire CAZIN Némo

← Version précédente		Version du 1 septembre 2023 à 13:41
Ligne 85 :		Ligne 85 :
	'''Le fichier APK de l'application est disponible dans le GIT du projet.'''		'''Le fichier APK de l'application est disponible dans le GIT du projet.'''

	= Epreuve complémentaire CAZIN Némo =		= '''Epreuve complémentaire CAZIN Némo''' =

	== Introduction : ==		== Introduction : ==

Ncazin : Rédaction rattrapages

2023-09-01T13:35:40Z

Rédaction rattrapages

Voir les modifications

Ncazin : Rattrapage save

2023-09-01T13:10:41Z

Rattrapage save

← Version précédente		Version du 1 septembre 2023 à 13:10
Ligne 84 :		Ligne 84 :

	'''Le fichier APK de l'application est disponible dans le GIT du projet.'''		'''Le fichier APK de l'application est disponible dans le GIT du projet.'''

			= Epreuve complémentaire CAZIN Némo =

			== Introduction : ==
			J’ai dû reprendre le projet lors de mon épreuve complémentaire de Semestre 6

			Avant cela, avec mon groupe de travail, nous avions réussi à faire clignoter une LED malgré tous les problèmes que nous avons rencontrés comme des composants qui ne fonctionnait plus sur la carte ou alors des courts circuits à faire nous-mêmes. Je ne traiterais donc pas ici la partie du clignotement de la LED.

			== Préparation de la carte électronique : ==
			Tout d’abord, lorsque j’ai repris le projet, je savais que les soudures des composants et du moteur continu avait été faites mais elles étaient fragiles du fait de la petite épaisseur des pistes reliant le moteur au driver. Cependant, le voyage de la boite avec la carte électronique à l’intérieur avait complétement cassé les soudures du moteur.

			Voici l’état de la carte lors de la reprise du projet :
			[[Fichier:Carte pas de soudure.jpg\|alt=Carte avec le moteur désoudé\|centré\|vignette\|Carte avec le moteur désoudé]]
			J’ai donc dû refaire les soudures du moteur, ce qui a été un peu compliqué car j’ai du mal à souder en général. Mais en m’inspirant des photos que j’avais d’avant la reprise du projet, j’ai pu mieux m’en sortir. Voilà le résultat de la soudure du moteur continu :
			[[Fichier:Carte moteur DC.jpg\|alt=Carte avec le moteur continu soudé\|centré\|vignette\|Carte avec le moteur continu soudé]]
			Après cela, j’ai voulu continuer mon travail en faisant les soudures du moteur pas-à-pas. Ce moteur est très petit et les soudures à faire devaient être très précises. Pour que ce soit plus simples, j’ai utilisé 4 pins que j’ai souder à la carte et sur les pins, des câbles sont reliés jusqu’aux quatre liaisons du moteur. Le moteur est alors déporté de la carte mais ce n’est pas très important car on veut juste le voir fonctionner et aucunes roues n’est attachées. Ces soudures étaient vraiment compliquées à réaliser car elles étaient très minutieuses et souvent des soudures se cassaient lorsque j’en soudais une autre.

			Voilà le résultat de la soudure du moteur pas à pas :
			[[Fichier:Carte moteur pap.jpg\|alt=Carte avec le moteur pas-à-pas soudé\|centré\|vignette\|Carte avec le moteur pas-à-pas soudé]]

			== Connexion de la carte sur ordinateur : ==
			Avant de commencer la programmation, j’ai voulu voir si la carte était toujours détectée grâce à la commande shell « '''''lsusb''''' » afin de savoir si le microcontrôleur n’avait pas lui aussi eu un problème pendant le voyage. J’ai alors rencontré plusieurs problèmes.

			En effet, j’avais commencé à développer mes programmes informatiques sur les machines de l’école à distance grâce à l’outil : '''https://tp-info.polytech-lille.fr/#''' . J’ai donc voulu voir si la carte était reconnue aussi depuis les machines à distances.

			Cependant, lorsque je me connecte sur ces machines, les périphériques USB de mon ordinateur ne sont pas reconnus. En faisant plusieurs essais pour résoudre ce problème, j’ai compris que ce n’était pas possible et donc qu’il fallait passer par une autre méthode. Sois-je faisais directement la programmation sur Windows mais télécharger les dépendances et le compilateur C allait être compliqué. Sois-je téléchargeais une machine virtuelle Ubuntu pour être directement sur un système Linux et plus simplement programmer. J’ai donc choisi la première option car je craignais que la machine virtuelle ne reconnaisse pas elle aussi les périphériques USB.

			J’ai donc modifié l’option développeur de mon Windows afin de pouvoir télécharger un environnement terminal Ubuntu qui fonctionne grâce à Windows Subsystem for Linux (WSL). J’ai alors rencontré une erreur lors du lancement du terminal Ubuntu :
			[[Fichier:Erreur Ubuntu.jpg\|alt=Erreur WSL pour Ubuntu\|centré\|vignette\|Erreur WSL pour Ubuntu]]
			J’ai alors trouvé une documentation de Microsoft sur le WSL qui m’a permis de résoudre ce problème ('''https://learn.microsoft.com/fr-fr/windows/wsl/troubleshooting'''). Après cela, j’ai voulu donc tester la commande « '''''lsusb''''' » mais encore une fois, une nouvelle erreur apparaît :
			[[Fichier:Erreur libusb.jpg\|alt=Erreur de la libusb sur Ubuntu\|centré\|vignette\|Erreur de la libusb sur Ubuntu]]
			J’ai donc télécharger la librairie libusb grâce à la commande « '''''sudo apt-get install libusb-1.0-0-dev''''' » que j’ai trouver grâce aux informations de ce site : '''https://askubuntu.com/questions/629619/how-to-install-libusb''' mais même en faisant cette commande, j’ai toujours eu la même erreur. Donc à ce stade du projet, je ne peux donc pas transférer et tester mes programmes, je vais continuer à chercher une solution.

			== Programmation du moteur continu : ==
			J’ai donc commencé par la partie du moteur continu car c’est sur cette partie que nous nous sommes arrêtés.

			Afin de faire fonctionner le moteur, je devais faire un programme informatique afin de gérer cette fonctionnalité. J’ai tout d’abord créé une fonction pour initialiser les ports du moteur comme étant des sorties. Ensuite, j’ai créé une fonction « avancer » où je mets un des ports sous tension et l’autre non. Pour la fonction « reculer », il s’agit de la même chose mais il faut inverser quel port est sous tension. Enfin pour la fonction « arrêter », il suffit de mettre les deux ports à 0.

			Voici donc le code pour faire fonctionner le moteur de cette façon :<syntaxhighlight lang="c">
			//////////////////////////////////////////
			/// INITIALISATION MOTEUR DC AVEC PORT ///
			//////////////////////////////////////////

			void initMotDC_Port(void){
			DDRB \|= (1<<PB7); //PMW2 en OUTPUT
			DDRD \|= (1<<PD0); //PMW1 en OUTPUT
			PORTB=(0<<PB7); //PMW2 à LOW
			PORTD=(0<<PD0); //PMW1 à LOW
			}

			////////////////////////////////////
			/// CONTROLE MOTEUR DC AVEC PORT ///
			////////////////////////////////////

			void move_forwards(void){
			PORTB=(1<<PB7); //MOT1 à HIGH
			PORTD=(0<<PD0); //MOT2 à LOW
			}

			void move_backwards(void){
			PORTB=(0<<PB7); //MOT1 à LOW
			PORTD=(1<<PD0); //MOT2 à HIGH
			}

			void stop(void){
			PORTB=(0<<PB7); //MOT1 à LOW
			PORTD=(0<<PD0); //MOT2 à LOW
			}
			</syntaxhighlight>Après avoir fait cela, je me suis demander si nous pouvions contrôler la vitesse du moteur. J’ai alors regardé trouver une page d’un cours de PSE ('''https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme053.html''')expliquant comment fonctionne les actionneurs simples grâce au signaux PWM (Pulse Width Modulation). Une partie du programme pour l’initialisation des ports était donnée, cependant il s’agissait de la gestion des sorties que je ne comprenais pas (OCR0A, OCR0B …), j’ai donc dû effectuer plusieurs recherches sur cette partie.

			Voici donc le code pour faire fonctionner le moteur de cette autre façon :<syntaxhighlight lang="c">
			//////////////////////////////////////////
			/// INITIALISATION MOTEUR DC AVEC OCR1 ///
			//////////////////////////////////////////

			void initMotDC_OCR(void){
			DDRB \|= (1<<PB7); //PMW2 en OUTPUT
			DDRD \|= (1<<PD0); //PMW1 en OUTPUT
			TCCR1A \|= (1<<COM1A1)\|(1<<COM1C1); // Les ports PWM se comportent normalement
			TCCR1A \|= (1<<WGM11)\|(1<<WGM10); // Minuteur mis en mode PWM
			TCCR1B \|= (1<<CS10); // Pas de pré-diviseur, démarre le compteur

			///////////////////////////////////
			/// CONTROLE MOTEUR DC AVEC OCR ///
			///////////////////////////////////

			void move_forwards_OCR(void){
			OCR1A = 512;
			OCR1C = 0;
			}

			void move_backwards_OCR(void){
			OCR1A = 0;
			OCR1C = 512;
			}

			void stop_OCR(void){
			OCR1A = 0;
			OCR1C = 0;
			}
			</syntaxhighlight>

			== Programmation du moteur pas à pas : ==

Ncazin : Suppression notes

2023-05-25T16:43:27Z

Suppression notes

← Version précédente		Version du 25 mai 2023 à 16:43
Ligne 83 :		Ligne 83 :
	</gallery>		</gallery>

	'''Le fichier APK de l'application est disponible dans le GIT du projet.'''		'''Le fichier APK de l'application est disponible dans le GIT du projet.'''

	~~==Notes : ==~~


	~~Séance 28/02~~

	~~Réalisation du PCB : Alim et chargeur à finir (faire gaffe aux deux nomenclatures)~~


	~~Séance 14/03~~

	~~Finition du schéma (alim, chargeur, led, port Série, Bluetooth àfinir), début routage~~

	~~https://www.ti.com/lit/ds/symlink/lm4040.pdf?ts=1678740694814&ref_url=https%253A%252F%252Fwww.ti.com%252Fproduct%252FLM4040~~

	https://docs.rs-online.com/f3fa/0900766b81623cc8.pdf<nowiki/>*


	~~Séance 21/03~~

	~~Schéma fini, manque des footprints à faire pour 3 composants --> routage~~



	~~Séance 11/04~~

	~~Routage terminé, retouche à faire (plan de masse etc..)~~


	~~Séance 2/05~~

	~~Réception de la carte~~

	~~Rédaction du wiki et soudure~~

Ncazin : Final

2023-05-25T16:42:38Z

Final

← Version précédente		Version du 25 mai 2023 à 16:42
Ligne 2 :		Ligne 2 :
	CAZIN Némo, CEGARRA Antoine, PALIFERRO Adrien		CAZIN Némo, CEGARRA Antoine, PALIFERRO Adrien

	Lien du git : [https://archives.plil.fr/ncazin/SE3_GROUPE_8.git]		'''Lien du git :''' ''https://archives.plil.fr/ncazin/SE3_GROUPE_8.git''

	==Objectifs fixés :==		==Objectifs fixés :==
	L'objectif principal de ce projet était de réaliser la commande d'une voiture au format 1:43 capable d'avancer et de reculer à l'aide d'un programme informatique. Avant de commencer le projet, nous nous sommes fixé plusieurs petits objectifs afin de mener au mieux le projet.		L'objectif principal de ce projet était de '''réaliser la commande d'une voiture au format 1:43''' capable d'avancer et de reculer à l'aide d'un programme informatique. Avant de commencer le projet, nous nous sommes fixé plusieurs petits objectifs afin de mener au mieux le projet.

	La voiture devait tout d'abord avancer, reculer, tourner à gauche et à droite. Des LEDs devaient être allumées lorsque la voiture effectue un déplacement.		La voiture devait tout d'abord avancer, reculer, tourner à gauche et à droite. Des LEDs devaient être allumées lorsque la voiture effectue un déplacement.
Ligne 13 :		Ligne 13 :
	Afin de pouvoir implémenter toutes ses fonctionnalités, nous devions réaliser une carte électronique gérée par un microcontrôleur ATMega16u2. D'autres module devaient être ajoutés pour la bonne réalisation de nos objectifs fixés.		Afin de pouvoir implémenter toutes ses fonctionnalités, nous devions réaliser une carte électronique gérée par un microcontrôleur ATMega16u2. D'autres module devaient être ajoutés pour la bonne réalisation de nos objectifs fixés.

	==La carte électronique : ==		==La carte électronique :==

	La réalisation de la carte électronique a débuté par la création du schéma électrique sur KICAD. Nous avons implémenté ce que nous avions déjà prévu (Chargeur, moteurs, microcontrôleur...), cependant, pour certaines fonctionnalités, des composants n'étaient pas disponibles dans les librairies Sparkfun disponibles.		La réalisation de la carte électronique a débuté par la création du schéma électrique sur KICAD. Nous avons implémenté ce que nous avions déjà prévu (Chargeur, moteurs, microcontrôleur...), cependant, pour certaines fonctionnalités, des composants n'étaient pas disponibles dans les librairies Sparkfun disponibles.
Ligne 39 :		Ligne 39 :
	Enfin, la carte étant vierge, nous devions commencer la soudure des composants. Cette partie a été très compliquée à mettre en oeuvre, car dans le groupe, aucun de nous n'avait fait de soudure dans sa vie. Nous avons donc dû apprendre à ce moment comment faire, d'où les premières soudures un peu compliquées.		Enfin, la carte étant vierge, nous devions commencer la soudure des composants. Cette partie a été très compliquée à mettre en oeuvre, car dans le groupe, aucun de nous n'avait fait de soudure dans sa vie. Nous avons donc dû apprendre à ce moment comment faire, d'où les premières soudures un peu compliquées.

	Nous avons eu un problème de reconnaissance du microprocesseur lors de la commande "lsusb", le matériel n'était pas détecté. Nous avons donc dû modifier le circuit qui comportait quelques erreurs, ainsi que remplacer les résistances et condensateurs afin de s'assurer de leur valeur. Finalement, nous avons dû changer le microprocesseur qui avec les précédents branchements avait surchauffé et était défectueux. Après avoir remplacé tous les composants, nous avons réussi à faire reconnaître le microprocesseur grâce à la commande "lsusb". Après cela, nous avons pu souder les derniers composants restants.		Nous avons eu un problème de reconnaissance du microprocesseur lors de la commande "''lsusb"'', le matériel n'était pas détecté. Nous avons donc dû modifier le circuit qui comportait quelques erreurs, ainsi que remplacer les résistances et condensateurs afin de s'assurer de leur valeur. Finalement, nous avons dû changer le microprocesseur qui avec les précédents branchements avait surchauffé et était défectueux. Après avoir remplacé tous les composants, nous avons réussi à faire reconnaître le microprocesseur grâce à la commande "''lsusb''". Après cela, nous avons pu souder les derniers composants restants.

	Voici une photo de notre carte avec les composants soudés :		Voici une photo de notre carte avec les composants soudés :
Ligne 62 :		Ligne 62 :

	==Application Bluetooth :==		==Application Bluetooth :==
	Nous nous étions fixé comme objectif que la voiture devait être contrôlée grâce à une application Bluetooth. Nous avons alors décidé de réaliser cette application grâce au site MIT App Inventor, ce site est simple d'utilisation et permet de gérer des communications Bluetooth facilement. De plus, le temps a été investi surtout dans la carte électronique donc apprendre et programmer par nous-même dans un langage de programmation nouveau aurait été compliqué pour nous.		Nous nous étions fixé comme objectif que la voiture devait être contrôlée grâce à une application Bluetooth. Nous avons alors décidé de réaliser cette application grâce au site '''MIT App Inventor''', ce site est simple d'utilisation et permet de gérer des communications Bluetooth facilement. De plus, le temps a été investi surtout dans la carte électronique donc apprendre et programmer par nous-même dans un langage de programmation nouveau aurait été compliqué pour nous.

	Nous avons décidé que les informations envoyées par communication Bluetooth serait sous forme hexadécimale. Le programme informatique du côté de l'ATMega16u2 recevra et traitera alors les informations reçues.		Nous avons décidé que les informations envoyées par communication Bluetooth serait sous forme hexadécimale. Le programme informatique du côté de l'ATMega16u2 recevra et traitera alors les informations reçues.
Ligne 82 :		Ligne 82 :
	Fichier:Gestion gyroscope.jpg\|Bloc de gestion du gyroscope		Fichier:Gestion gyroscope.jpg\|Bloc de gestion du gyroscope
	</gallery>		</gallery>

			'''Le fichier APK de l'application est disponible dans le GIT du projet.'''

	==Notes : ==		==Notes : ==

Ncazin : ajout photos

2023-05-25T16:24:11Z

ajout photos

← Version précédente		Version du 25 mai 2023 à 16:24
Ligne 2 :		Ligne 2 :
	CAZIN Némo, CEGARRA Antoine, PALIFERRO Adrien		CAZIN Némo, CEGARRA Antoine, PALIFERRO Adrien

	== Objectifs fixés : ==		Lien du git : [https://archives.plil.fr/ncazin/SE3_GROUPE_8.git]

			==Objectifs fixés :==
	L'objectif principal de ce projet était de réaliser la commande d'une voiture au format 1:43 capable d'avancer et de reculer à l'aide d'un programme informatique. Avant de commencer le projet, nous nous sommes fixé plusieurs petits objectifs afin de mener au mieux le projet.		L'objectif principal de ce projet était de réaliser la commande d'une voiture au format 1:43 capable d'avancer et de reculer à l'aide d'un programme informatique. Avant de commencer le projet, nous nous sommes fixé plusieurs petits objectifs afin de mener au mieux le projet.

Ligne 11 :		Ligne 13 :
	Afin de pouvoir implémenter toutes ses fonctionnalités, nous devions réaliser une carte électronique gérée par un microcontrôleur ATMega16u2. D'autres module devaient être ajoutés pour la bonne réalisation de nos objectifs fixés.		Afin de pouvoir implémenter toutes ses fonctionnalités, nous devions réaliser une carte électronique gérée par un microcontrôleur ATMega16u2. D'autres module devaient être ajoutés pour la bonne réalisation de nos objectifs fixés.

	== La carte électronique : ==		==La carte électronique : ==

	La réalisation de la carte électronique a débuté par la création du schéma électrique sur KICAD. Nous avons implémenté ce que nous avions déjà prévu (Chargeur, moteurs, microcontrôleur...), cependant, pour certaines fonctionnalités, des composants n'étaient pas disponibles dans les librairies Sparkfun disponibles.		La réalisation de la carte électronique a débuté par la création du schéma électrique sur KICAD. Nous avons implémenté ce que nous avions déjà prévu (Chargeur, moteurs, microcontrôleur...), cependant, pour certaines fonctionnalités, des composants n'étaient pas disponibles dans les librairies Sparkfun disponibles.
Ligne 31 :		Ligne 33 :
	Voici une image du routage final notre carte électronique :		Voici une image du routage final notre carte électronique :
	[[Fichier:Routage voiture.jpg\|alt=Routage de la carte électronique\|centré\|vignette\|Routage de la carte électronique]]		[[Fichier:Routage voiture.jpg\|alt=Routage de la carte électronique\|centré\|vignette\|Routage de la carte électronique]]
			Voici aussi une représentation 3D de notre carte électronique :
			[[Fichier:Pcb 3D.jpg\|alt=Représentation 3D de notre carte électronique\|centré\|vignette\|Représentation 3D de notre carte électronique]]
	Le routage fini, nous avons passé commande afin de recevoir notre carte électronique et voici celle-ci avec aucune soudure :		Le routage fini, nous avons passé commande afin de recevoir notre carte électronique et voici celle-ci avec aucune soudure :

Ligne 38 :		Ligne 42 :

	Voici une photo de notre carte avec les composants soudés :		Voici une photo de notre carte avec les composants soudés :
			[[Fichier:Carte électronique avec les composants soudés.jpg\|alt=Carte électronique avec les composants soudés\|centré\|vignette\|Carte électronique avec les composants soudés]]
	Nous avions fini la carte électronique, sa réalisation a pris la majeure partie de notre temps lors des séances. Il fallait donc ensuite réaliser un programme permettant de faire fonctionner et avancer la voiture.		Nous avions fini la carte électronique, sa réalisation a pris la majeure partie de notre temps lors des séances. Il fallait donc ensuite réaliser un programme permettant de faire fonctionner et avancer la voiture.

	Fichier ZIP de notre carte électronique : [[Fichier:Voiture CCP.zip\|vignette\|Voiture fichiers de routage et schéma PCB]]		Fichier ZIP de notre carte électronique : [[Fichier:Voiture CCP.zip\|vignette\|Voiture fichiers de routage et schéma PCB]]

	== Programme de la voiture : ==		==Programme de la voiture :==
	Le programme informatique était nécessaire pour le bon fonctionnement de la voiture, cependant comme le temps commençait à manquer, nous avons codé son programme en dehors des cours de projet.		Le programme informatique était nécessaire pour le bon fonctionnement de la voiture, cependant comme le temps commençait à manquer, nous avons codé son programme en dehors des cours de projet.

Ligne 55 :		Ligne 59 :

	Voici une vidéo de la carte avec une LED qui clignote :		Voici une vidéo de la carte avec une LED qui clignote :
			[[Fichier:PCB clignote.mov\|alt=LED qui clignote\|centré\|vignette\|LED qui clignote]]

	== Application Bluetooth : ==		==Application Bluetooth :==
	Nous nous étions fixé comme objectif que la voiture devait être contrôlée grâce à une application Bluetooth. Nous avons alors décidé de réaliser cette application grâce au site MIT App Inventor, ce site est simple d'utilisation et permet de gérer des communications Bluetooth facilement. De plus, le temps a été investi surtout dans la carte électronique donc apprendre et programmer par nous-même dans un langage de programmation nouveau aurait été compliqué pour nous.		Nous nous étions fixé comme objectif que la voiture devait être contrôlée grâce à une application Bluetooth. Nous avons alors décidé de réaliser cette application grâce au site MIT App Inventor, ce site est simple d'utilisation et permet de gérer des communications Bluetooth facilement. De plus, le temps a été investi surtout dans la carte électronique donc apprendre et programmer par nous-même dans un langage de programmation nouveau aurait été compliqué pour nous.

Ligne 78 :		Ligne 83 :
	</gallery>		</gallery>

	== Notes : ==		==Notes : ==

Ncazin le 23 mai 2023 à 13:49

2023-05-23T13:49:25Z

← Version précédente		Version du 23 mai 2023 à 13:49
Ligne 53 :		Ligne 53 :

	La communication Bluetooth étant un de nos objectifs fixé, nous avons dû réaliser une application afin de pouvoir utiliser la voiture à distance.		La communication Bluetooth étant un de nos objectifs fixé, nous avons dû réaliser une application afin de pouvoir utiliser la voiture à distance.

			Voici une vidéo de la carte avec une LED qui clignote :

	== Application Bluetooth : ==		== Application Bluetooth : ==

Ncazin : correction fautes

2023-05-19T18:30:51Z

correction fautes

← Version précédente		Version du 19 mai 2023 à 18:30
Ligne 3 :		Ligne 3 :

	== Objectifs fixés : ==		== Objectifs fixés : ==
	L'objectif principal de ce projet était de réaliser la commande d'une voiture au format 1:43 capable d'avancer et reculer à l'~~aie~~ d'un programme informatique. Avant de commencer le projet, nous nous sommes fixé plusieurs petits ~~objectif~~ afin de mener au mieux le projet.		L'objectif principal de ce projet était de réaliser la commande d'une voiture au format 1:43 capable d'avancer et de reculer à l'aide d'un programme informatique. Avant de commencer le projet, nous nous sommes fixé plusieurs petits objectifs afin de mener au mieux le projet.

	La voiture devait tout d'abord avancer, reculer, tourner à gauche et à droite. Des LEDs ~~devait~~ être allumées lorsque la voiture effectue un déplacement.		La voiture devait tout d'abord avancer, reculer, tourner à gauche et à droite. Des LEDs devaient être allumées lorsque la voiture effectue un déplacement.

	Pour la commande de la voiture, nous voulions qu'elle soit commandée grâce à une commande Bluetooth et pilotée depuis un smartphone. Une application devait alors être ~~faites~~ pour gérer les déplacements. MIT App Inventor permet de gérer des communications Bluetooth et est simple d'utilisation.		Pour la commande de la voiture, nous voulions qu'elle soit commandée grâce à une commande Bluetooth et pilotée depuis un smartphone. Une application devait alors être faite pour gérer les déplacements. MIT App Inventor permet de gérer des communications Bluetooth et est simple d'utilisation.

	Afin de pouvoir implémenter toutes ses fonctionnalités, nous devions réaliser une carte électronique gérée par un microcontrôleur ATMega16u2. D'autres module devaient être ajoutés pour la bonne réalisation de nos objectifs fixés.		Afin de pouvoir implémenter toutes ses fonctionnalités, nous devions réaliser une carte électronique gérée par un microcontrôleur ATMega16u2. D'autres module devaient être ajoutés pour la bonne réalisation de nos objectifs fixés.
Ligne 13 :		Ligne 13 :
	== La carte électronique : ==		== La carte électronique : ==

	La réalisation de la carte électronique a ~~débutée~~ par la création du schéma électrique sur KICAD. Nous avons implémenté ce que nous ~~aviosn~~ déjà prévu (Chargeur, moteurs, ~~microcontrolleur~~...), cependant, pour certaines fonctionnalités, des composants n'étaient pas disponibles dans les librairies Sparkfun disponibles.		La réalisation de la carte électronique a débuté par la création du schéma électrique sur KICAD. Nous avons implémenté ce que nous avions déjà prévu (Chargeur, moteurs, microcontrôleur...), cependant, pour certaines fonctionnalités, des composants n'étaient pas disponibles dans les librairies Sparkfun disponibles.

	Nous avons donc créé les schémas de ces composants, c'est-à-dire le module Bluetooth '''FP-BM70BLE01FC2''' ainsi que le driver du moteur '''DRV8210DRL''' grâce aux informations de leurs datasheet disponible sur ~~internet~~ :		Nous avons donc créé les schémas de ces composants, c'est-à-dire le module Bluetooth '''FP-BM70BLE01FC2''' ainsi que le driver du moteur '''DRV8210DRL''' grâce aux informations de leurs datasheet disponible sur Internet :

	- Datasheet du module Bluetooth : ''https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/BM70_71-Bluetooth-Low-Energy-BLE-Module-DS60001372L.pdf''		- Datasheet du module Bluetooth : ''https://ww1.microchip.com/downloads/aemDocuments/documents/OTH/ProductDocuments/DataSheets/BM70_71-Bluetooth-Low-Energy-BLE-Module-DS60001372L.pdf''
Ligne 23 :		Ligne 23 :
	Au final, nous obtenons au final ce schéma correspondant :		Au final, nous obtenons au final ce schéma correspondant :
	[[Fichier:Schématic voiture.jpg\|alt=Schéma de la voiture\|centré\|vignette\|Schéma de la voiture]]		[[Fichier:Schématic voiture.jpg\|alt=Schéma de la voiture\|centré\|vignette\|Schéma de la voiture]]
	Après avoir fait le schéma de la voiture, nous avons dû faire le routage de la carte électronique. La première chose à faire à été de prendre les côtes de la voiture afin que la carte électronique se mette bien en place dessus. De plus nous avons dû prendre les mesures des côtes du moteur continu, celui-ci va être soudé au centre de la carte et est imposant, il fallait donc prévoir la place nécessaire que le composant prendrait.		Après avoir fait le schéma de la voiture, nous avons dû faire le routage de la carte électronique. La première chose a faire à été de prendre les côtes de la voiture afin que la carte électronique se mette bien en place dessus. De plus, nous avons dû prendre les mesures des côtes du moteur continu, celui-ci va être soudé au centre de la carte et est imposant, il fallait donc prévoir la place nécessaire que le composant prendrait.

	Ensuite, nous avons dû réaliser les empreintes du module Bluetooth ainsi que du driver du moteur. Les mesures figurant sur leurs datasheet respectives, nous avons réussi simplement à les reproduire. Le plus compliqué a été de repérer les pâtes des composants que nous devions utiliser. Par exemple, sur le module Bluetooth, certaines entrées n'ont pas été utilisées. Nous avons aussi ~~utiliser~~ et adapter les empreintes des moteurs continus et pas à pas fournis par notre professeur M.Redon.		Ensuite, nous avons dû réaliser les empreintes du module Bluetooth ainsi que du driver du moteur. Les mesures figurant sur leurs datasheet respectives, nous avons réussi simplement à les reproduire. Le plus compliqué a été de repérer les pâtes des composants que nous devions utiliser. Par exemple, sur le module Bluetooth, certaines entrées n'ont pas été utilisées. Nous avons aussi utilisé et adapter les empreintes des moteurs continus et pas à pas fournis par notre professeur M.Redon.

	Après cela, nous avons ~~commencer~~ le routage. Nous avons commencer par router la carte le plus possible sur une seule face jusqu'à ce que ne l'on puisse plus. Sinon nous utilisions des ~~via~~ afin de router sur l'autre face. Cependant, nous avons dû recommencer une seconde fois le routage car le premier ne nous convenait pas. Nous avons aussi ~~demander~~ de l'aide au professeur M.Boé afin de réaliser les plans de masse.		Après cela, nous avons commencé le routage. Nous avons commencer par router la carte le plus possible sur une seule face jusqu'à ce que ne l'on puisse plus. Sinon nous utilisions des vias afin de router sur l'autre face. Cependant, nous avons dû recommencer une seconde fois le routage, car le premier ne nous convenait pas. Nous avons aussi demandé de l'aide au professeur M.Boé afin de réaliser les plans de masse.

	Voici une image du routage final notre carte électronique :		Voici une image du routage final notre carte électronique :
Ligne 33 :		Ligne 33 :
	Le routage fini, nous avons passé commande afin de recevoir notre carte électronique et voici celle-ci avec aucune soudure :		Le routage fini, nous avons passé commande afin de recevoir notre carte électronique et voici celle-ci avec aucune soudure :

	Enfin, la carte étant vierge, nous devions commencer la soudure des composants. Cette partie a été très ~~compliqué~~ à mettre en oeuvre, car dans le groupe, aucun de nous n'avait fait de soudure dans sa vie. Nous avons donc dû apprendre à ce moment comment faire, d'où les premières soudures un peu compliquées.		Enfin, la carte étant vierge, nous devions commencer la soudure des composants. Cette partie a été très compliquée à mettre en oeuvre, car dans le groupe, aucun de nous n'avait fait de soudure dans sa vie. Nous avons donc dû apprendre à ce moment comment faire, d'où les premières soudures un peu compliquées.

	Nous avons eu un problème de reconnaissance du microprocesseur lors de la commande "lsusb", le matériel n'était pas détecté. Nous avons donc du modifier le circuit qui comportait quelques erreurs, ainsi que remplacer les résistances et condensateurs afin de s'assurer de leur valeur. Finalement, nous avons dû changer le microprocesseur qui avec les précédents branchements avait surchauffé et était défectueux. Après avoir ~~avoir remplacer tout~~ les composants, nous avons réussi à faire reconnaître le microprocesseur grâce à la commande "lsusb". Après cela, nous avons pû souder les derniers composants restants.		Nous avons eu un problème de reconnaissance du microprocesseur lors de la commande "lsusb", le matériel n'était pas détecté. Nous avons donc dû modifier le circuit qui comportait quelques erreurs, ainsi que remplacer les résistances et condensateurs afin de s'assurer de leur valeur. Finalement, nous avons dû changer le microprocesseur qui avec les précédents branchements avait surchauffé et était défectueux. Après avoir remplacé tous les composants, nous avons réussi à faire reconnaître le microprocesseur grâce à la commande "lsusb". Après cela, nous avons pu souder les derniers composants restants.

	Voici une photo de notre carte avec les composants ~~soudées~~ :		Voici une photo de notre carte avec les composants soudés :

	Nous avions fini la carte électronique, sa réalisation a pris la majeure partie de notre temps lors des séances. Il fallait donc ensuite ~~réalisé~~ un programme permettant de faire fonctionner et avancer la voiture.		Nous avions fini la carte électronique, sa réalisation a pris la majeure partie de notre temps lors des séances. Il fallait donc ensuite réaliser un programme permettant de faire fonctionner et avancer la voiture.

	Fichier ZIP de notre carte électronique : [[Fichier:Voiture CCP.zip\|vignette\|Voiture fichiers de routage et schéma PCB]]		Fichier ZIP de notre carte électronique : [[Fichier:Voiture CCP.zip\|vignette\|Voiture fichiers de routage et schéma PCB]]
Ligne 46 :		Ligne 46 :
	Le programme informatique était nécessaire pour le bon fonctionnement de la voiture, cependant comme le temps commençait à manquer, nous avons codé son programme en dehors des cours de projet.		Le programme informatique était nécessaire pour le bon fonctionnement de la voiture, cependant comme le temps commençait à manquer, nous avons codé son programme en dehors des cours de projet.

	Nous avons donc ~~structurer~~ notre code en plusieurs afin de le simplifier. Les premières fonctions permettent d'initialiser les entrées et les sorties du ~~microcontrôlleur~~ afin de bien récupérer et envoyer les bonnes informations. De plus, dans ces fonctions, nous remettons les moteurs et les leds à LOW afin d'avoir une sécurité et qu'ils ne démarrent pas à l'initialisation. Ensuite, nous retrouvons les fonctions de déplacements. Ces fonctions gèrent les moteurs lorsqu'il faut avancer, reculer, tourner à droite etc...		Nous avons donc structuré notre code en plusieurs afin de le simplifier. Les premières fonctions permettent d'initialiser les entrées et les sorties du microcontrôleur afin de bien récupérer et envoyer les bonnes informations. De plus, dans ces fonctions, nous remettons les moteurs et les leds à LOW afin d'avoir une sécurité et qu'ils ne démarrent pas à l'initialisation. Ensuite, nous retrouvons les fonctions de déplacements. Ces fonctions gèrent les moteurs lorsqu'il faut avancer, reculer, tourner à droite, etc...

	De plus, on retrouve une fonction permettant de ~~récuper~~ les informations ~~envoyés~~ depuis la communication Bluetooth afin de faire fonctionner la voiture à distance. Une seconde fonction permet de traiter ces informations et de faire déplacer la voiture ~~celon~~ l'information reçue.		De plus, on retrouve une fonction permettant de récupérer les informations envoyées depuis la communication Bluetooth afin de faire fonctionner la voiture à distance. Une seconde fonction permet de traiter ces informations et de faire déplacer la voiture selon l'information reçue.

	Nous pouvons aussi faire fonctionner la voiture en envoyant le programme informatique dans la voiture. Cependant, de cette manière, la voiture ne pourra pas être ~~controllé~~ et fera un trajet voulu.		Nous pouvons aussi faire fonctionner la voiture en envoyant le programme informatique dans la voiture. Cependant, de cette manière, la voiture ne pourra pas être contrôlée et fera un trajet voulu.

	La communication Bluetooth étant un de nos ~~objectif~~ fixé, nous avons dû réaliser une application afin de pouvoir utiliser la voiture à distance.		La communication Bluetooth étant un de nos objectifs fixé, nous avons dû réaliser une application afin de pouvoir utiliser la voiture à distance.

	== Application Bluetooth : ==		== Application Bluetooth : ==
	Nous nous étions fixé comme objectif que la voiture devait être contrôlée grâce à une application Bluetooth. Nous avons alors décidé de réaliser cette application grâce au site MIT App Inventor, ce site est simple d'utilisation et permet de gérer des communications Bluetooth facilement. De plus, le temps a ~~était~~ investi surtout dans la carte électronique donc apprendre et programmer par nous même dans un langage de programmation nouveau aurait été compliqué pour nous.		Nous nous étions fixé comme objectif que la voiture devait être contrôlée grâce à une application Bluetooth. Nous avons alors décidé de réaliser cette application grâce au site MIT App Inventor, ce site est simple d'utilisation et permet de gérer des communications Bluetooth facilement. De plus, le temps a été investi surtout dans la carte électronique donc apprendre et programmer par nous-même dans un langage de programmation nouveau aurait été compliqué pour nous.

	Nous avons ~~décider~~ que les informations envoyées par communication Bluetooth serait sous forme hexadécimale. Le programme informatique du côté de l'ATMega16u2 recevra et traitera alors les informations reçues.		Nous avons décidé que les informations envoyées par communication Bluetooth serait sous forme hexadécimale. Le programme informatique du côté de l'ATMega16u2 recevra et traitera alors les informations reçues.

	L'application devait avoir un aspect simple d'utilisation et sobre afin de faciliter l'expérience de l'utilisateur. L'application amènerait l'utilisateur sur une page permettant de choisir à ~~quelle~~ appareil Bluetooth se connecter. Un statut indiquant si le smartphone est connecté ou non à l'appareil est aussi présent. L'élément le plus important de la page est le bloc de déplacement, composé de 4 boutons représentant des flèches directionnelles afin de piloter la voiture.		L'application devait avoir un aspect simple d'utilisation et sobre afin de faciliter l'expérience de l'utilisateur. L'application amènerait l'utilisateur sur une page permettant de choisir à quel appareil Bluetooth se connecter. Un statut indiquant si le smartphone est connecté ou non à l'appareil est aussi présent. L'élément le plus important de la page est le bloc de déplacement, composé de 4 boutons représentant des flèches directionnelles afin de piloter la voiture.

	Lorsque nous avions terminé l'application pour piloter grâce à des flèches directionnelles, nous nous sommes rendu compte que nous pourrions réaliser aussi un pilotage par gyroscope. En effet, les informations transmises pour les déplacements ~~reste~~ les mêmes donc du côté du programme informatique, rien ne change. Nous avons deux moyens de piloter la voiture : une par ~~appuis~~ sur des flèches directionnelles, et une seconde par ~~inclinaisons~~ du smartphone.		Lorsque nous avions terminé l'application pour piloter grâce à des flèches directionnelles, nous nous sommes rendu compte que nous pourrions réaliser aussi un pilotage par gyroscope. En effet, les informations transmises pour les déplacements restent les mêmes donc du côté du programme informatique, rien ne change. Nous avons deux moyens de piloter la voiture : une par appui sur des flèches directionnelles, et une seconde par inclinaison du smartphone.

	Voilà des captures d'écran montrant l'aspect et les fonctionnalités de l'application :		Voilà des captures d'écran montrant l'aspect et les fonctionnalités de l'application :

SE3Trinome2022-8 - Historique des versions

Ncazin : modif et correction

Ncazin : /* Connexion de la carte sur ordinateur : */

Ncazin : /* Epreuve complémentaire CAZIN Némo */

Ncazin : Rédaction rattrapages

Ncazin : Rattrapage save

Ncazin : Suppression notes

Ncazin : Final

Ncazin : ajout photos