https://wiki-ima.plil.fr/mediawiki//api.php?action=feedcontributions&feedformat=atom&user=Nalexand 2026-05-13T02:01:09Z Contributions de l’utilisateur MediaWiki 1.29.2 https://wiki-ima.plil.fr/mediawiki//index.php?title=P27_Controle_Direct_de_Puissance_d%27un_Convertisseur_Matriciel&diff=17728 2015-02-24T11:10:09Z

<p>Nalexand : /* Vidéo */</p> <hr /> <div>== Présentation du projet ==<br /> L'objectif de l'étude consiste à élaborer une commande de type DPC (Direct Power Control) pour un<br /> convertisseur matriciel.<br /> <br /> <br /> [[Fichier:Matrix converter DPC.png|upright=4 |thumb|centre]]<br /> <br /> == Prestations attendues ==<br /> Notre travail va se dérouler en plusieurs étapes :<br /> - Etude Bibliographique du convertisseur matriciel et de la commande DPC<br /> - Compréhension et prise en main du contrôle direct sur un redresseur MLI<br /> - Prise en main du convertisseur matriciel et des commandes associées<br /> - Elaboration de la commande DPC pour convertisseur matriciel<br /> - Implantation sous Matlab Simulink<br /> - Simulation de la structure et analyse des résultats<br /> <br /> == Ressources disponibles ==<br /> - Publications de différentes recherches sur le site www.ieee.org<br /> - Modèle Simulink de la commande DPC d'un redresseur MLI<br /> - Modèle Simulink de différentes commandes (autres que DPC) d'un convertisseur matriciel<br /> <br /> == Déroulement du projet ==<br /> <br /> === SEMAINE 1 ===<br /> Prise en main du sujet.<br /> <br /> <br /> === SEMAINE 2 ===<br /> <br /> Rendez-vous réalisé avec notre tuteur, Mr Delarue, celui-ci nous explique le principe général d'un contrôle directe de puissance (DPC), l'avantage que cela représenterai pour les industriels, les moyens d'asservissement de redresseur aujourd'hui.<br /> <br /> Présentation du site IEEE explore, accessible à partir de l'école polytech. Celui-ci permet de trouver différent papier publiés par des chercheurs grâce à un système de mot clés.<br /> <br /> <br /> === SEMAINE 3 ===<br /> Recherche bibliographique sur la DPC (fonctionnement, avantages, utilisation, implémentation,...)<br /> <br /> <br /> === SEMAINE 4 ===<br /> <br /> Recherche bibliographique sur les convertisseur matriciel. (fonctionnement, composition, avantages,...)<br /> Présentation des résultats de nos recherches auprès de notre tuteur.<br /> <br /> <br /> === SEMAINE 5 ===<br /> <br /> Approfondissement de nos recherches, à ce stade nous avons étudier environs une dizaine de rapport de chercheur.<br /> <br /> - Calcul des puissance active et réactive, utilisation des transformée de Park et de Concordia pour trouver les composantes directes et de quadratures des tensions/courants.<br /> <br /> <br /> === SEMAINE 6 ===<br /> <br /> - Soumissions à notre tuteur de plusieurs papier, on choisit de se baser sur l'un d'eux pour comprendre le système proposé et l'implanter sous Matlab<br /> <br /> <br /> === SEMAINE 7 ===<br /> <br /> - étude des comparateurs à hystérésis, ainsi que du régulateur de tension continu du système.<br /> - Prise en main du convertisseur MLI auquel est appliqué une commande DPC sous Matlab (fichier remis par notre tuteur).<br /> <br /> === SEMAINE 8 ===<br /> <br /> - Etude de la table de commutation, des paramètres d'entrée et de sortie.<br /> - Les bits de sortie dépendant des valeurs des deux booléens d'entrée (représentant les erreurs des puissances réactive et actives).<br /> - Les valeurs du tableau reste à définir.<br /> <br /> <br /> === SEMAINE 9 === <br /> - Prise en main du convertisseur matriciel sous Matlab avec la commande DPC, étude de son fonctionnement, de la manière dont il commute. (fichier remis par notre tuteur).<br /> <br /> === SEMAINE 10 ===<br /> - Etude afin d'adapter la commande DPC à un convertisseur matriciel.<br /> - Nous avons obtenus de nombreux papiers de chercheurs sur le site ieee.org, dont un en particulier : <br /> « Direct Power Control Based Matrix Converter and Its Operation Characteristics » <br /> <br /> === SEMAINE 11 ===<br /> - Afin de contrôler le convertisseur matriciel AC/AC, nous allons le décomposer en deux parties : Redresseur (AC/DC) et inverseur (DC/AC).<br /> <br /> [[Fichier:Converter_inverter.png|upright=4 |thumb|centre]]<br /> <br /> - Nous allons étudier la commande de ces deux parties, le redresseur se commande avec le DPC et l'inverseur avec une commande MLI.<br /> <br /> === SEMAINE 12 ===<br /> - Commande DPC du redresseur :<br /> [[Fichier:DPC_converter.png|upright=4 |thumb|centre]]<br /> <br /> - Il faut contrôler les 6 interrupteurs du redresseur à partir d'une table de commutation qui va envoyer 6 signaux (0 ou 1).<br /> - Ces signaux sont obtenus en fonction de la valeur de la puissance instantanée comparée à une puissance de référence.<br /> <br /> === SEMAINE 13 ===<br /> - Réalisation de la commande DPC du redresseur virtuel sur Simulink.<br /> Réalisation de la table de commutation sous forme de fonction Matlab puis sous forme de bloc logique.<br /> <br /> === SEMAINE 14 ===<br /> - Commande MLI de la partie virtuelle inverseur.<br /> [[Fichier:DPC_converter.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 15 ===<br /> - Réalisation de la partie commande de l'inverseur virtuel :<br /> [[Fichier:Virtual_inverter.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 16 ===<br /> - Etude de la partie Latch de la commande de l'inverseur.<br /> Il faut en effet faire attention aux courts-circuits qui peuvent être provoqués lors de la commutation des interrupteurs du redresseur (si Sp et Sq sont tous les deux égaux à 0 en même temps, ce sont les erreurs entre P_inst et P_ref). S'il y a un court-circuit au niveau du bus continu, alors le latch doit bloquer les signaux qui contrôlent l'inverseur.<br /> <br /> === SEMAINE 17 ===<br /> - Concaténation des deux matrices de commande afin d'obtenir une matrice [3x3] pour commande les interrupteurs du convertisseur matriciel.<br /> - Création du schéma final sur Simulink.<br /> [[Fichier:Matric_converter_simulink.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 18 ===<br /> - Réglage des filtres d'entrée et de sortie pour la simulation<br /> - Réglage des différents paramètres des comparateurs hystérésis, three-phase carrier et correcteur P.<br /> <br /> === SEMAINE 19 ===<br /> - Analyse des résultats :<br /> Quelques problèmes au niveau des signaux de sorties. La puissance de référence calculée avec l'inverseur varie beaucoup.<br /> Les courants en sorties de l'inverseur sont bien sinusoïdaux et on observe bien le découpage des signaux sur la figure suivante :<br /> [[Fichier:Courants_de_sortie.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 20 ===<br /> - Préparation du rapport et de la soutenance.<br /> - Réalisation de la vidéo.<br /> <br /> <br /> <br /> == Vidéo ==<br /> Lien Youtube de la vidéo du projet : http://youtu.be/9_q-TNGuCnI<br /> Ou en télechargement sur le wiki [[Fichier:PFE.mp4]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=P27_Controle_Direct_de_Puissance_d%27un_Convertisseur_Matriciel&diff=17727 2015-02-24T11:09:33Z

<p>Nalexand : /* Vidéo */</p> <hr /> <div>== Présentation du projet ==<br /> L'objectif de l'étude consiste à élaborer une commande de type DPC (Direct Power Control) pour un<br /> convertisseur matriciel.<br /> <br /> <br /> [[Fichier:Matrix converter DPC.png|upright=4 |thumb|centre]]<br /> <br /> == Prestations attendues ==<br /> Notre travail va se dérouler en plusieurs étapes :<br /> - Etude Bibliographique du convertisseur matriciel et de la commande DPC<br /> - Compréhension et prise en main du contrôle direct sur un redresseur MLI<br /> - Prise en main du convertisseur matriciel et des commandes associées<br /> - Elaboration de la commande DPC pour convertisseur matriciel<br /> - Implantation sous Matlab Simulink<br /> - Simulation de la structure et analyse des résultats<br /> <br /> == Ressources disponibles ==<br /> - Publications de différentes recherches sur le site www.ieee.org<br /> - Modèle Simulink de la commande DPC d'un redresseur MLI<br /> - Modèle Simulink de différentes commandes (autres que DPC) d'un convertisseur matriciel<br /> <br /> == Déroulement du projet ==<br /> <br /> === SEMAINE 1 ===<br /> Prise en main du sujet.<br /> <br /> <br /> === SEMAINE 2 ===<br /> <br /> Rendez-vous réalisé avec notre tuteur, Mr Delarue, celui-ci nous explique le principe général d'un contrôle directe de puissance (DPC), l'avantage que cela représenterai pour les industriels, les moyens d'asservissement de redresseur aujourd'hui.<br /> <br /> Présentation du site IEEE explore, accessible à partir de l'école polytech. Celui-ci permet de trouver différent papier publiés par des chercheurs grâce à un système de mot clés.<br /> <br /> <br /> === SEMAINE 3 ===<br /> Recherche bibliographique sur la DPC (fonctionnement, avantages, utilisation, implémentation,...)<br /> <br /> <br /> === SEMAINE 4 ===<br /> <br /> Recherche bibliographique sur les convertisseur matriciel. (fonctionnement, composition, avantages,...)<br /> Présentation des résultats de nos recherches auprès de notre tuteur.<br /> <br /> <br /> === SEMAINE 5 ===<br /> <br /> Approfondissement de nos recherches, à ce stade nous avons étudier environs une dizaine de rapport de chercheur.<br /> <br /> - Calcul des puissance active et réactive, utilisation des transformée de Park et de Concordia pour trouver les composantes directes et de quadratures des tensions/courants.<br /> <br /> <br /> === SEMAINE 6 ===<br /> <br /> - Soumissions à notre tuteur de plusieurs papier, on choisit de se baser sur l'un d'eux pour comprendre le système proposé et l'implanter sous Matlab<br /> <br /> <br /> === SEMAINE 7 ===<br /> <br /> - étude des comparateurs à hystérésis, ainsi que du régulateur de tension continu du système.<br /> - Prise en main du convertisseur MLI auquel est appliqué une commande DPC sous Matlab (fichier remis par notre tuteur).<br /> <br /> === SEMAINE 8 ===<br /> <br /> - Etude de la table de commutation, des paramètres d'entrée et de sortie.<br /> - Les bits de sortie dépendant des valeurs des deux booléens d'entrée (représentant les erreurs des puissances réactive et actives).<br /> - Les valeurs du tableau reste à définir.<br /> <br /> <br /> === SEMAINE 9 === <br /> - Prise en main du convertisseur matriciel sous Matlab avec la commande DPC, étude de son fonctionnement, de la manière dont il commute. (fichier remis par notre tuteur).<br /> <br /> === SEMAINE 10 ===<br /> - Etude afin d'adapter la commande DPC à un convertisseur matriciel.<br /> - Nous avons obtenus de nombreux papiers de chercheurs sur le site ieee.org, dont un en particulier : <br /> « Direct Power Control Based Matrix Converter and Its Operation Characteristics » <br /> <br /> === SEMAINE 11 ===<br /> - Afin de contrôler le convertisseur matriciel AC/AC, nous allons le décomposer en deux parties : Redresseur (AC/DC) et inverseur (DC/AC).<br /> <br /> [[Fichier:Converter_inverter.png|upright=4 |thumb|centre]]<br /> <br /> - Nous allons étudier la commande de ces deux parties, le redresseur se commande avec le DPC et l'inverseur avec une commande MLI.<br /> <br /> === SEMAINE 12 ===<br /> - Commande DPC du redresseur :<br /> [[Fichier:DPC_converter.png|upright=4 |thumb|centre]]<br /> <br /> - Il faut contrôler les 6 interrupteurs du redresseur à partir d'une table de commutation qui va envoyer 6 signaux (0 ou 1).<br /> - Ces signaux sont obtenus en fonction de la valeur de la puissance instantanée comparée à une puissance de référence.<br /> <br /> === SEMAINE 13 ===<br /> - Réalisation de la commande DPC du redresseur virtuel sur Simulink.<br /> Réalisation de la table de commutation sous forme de fonction Matlab puis sous forme de bloc logique.<br /> <br /> === SEMAINE 14 ===<br /> - Commande MLI de la partie virtuelle inverseur.<br /> [[Fichier:DPC_converter.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 15 ===<br /> - Réalisation de la partie commande de l'inverseur virtuel :<br /> [[Fichier:Virtual_inverter.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 16 ===<br /> - Etude de la partie Latch de la commande de l'inverseur.<br /> Il faut en effet faire attention aux courts-circuits qui peuvent être provoqués lors de la commutation des interrupteurs du redresseur (si Sp et Sq sont tous les deux égaux à 0 en même temps, ce sont les erreurs entre P_inst et P_ref). S'il y a un court-circuit au niveau du bus continu, alors le latch doit bloquer les signaux qui contrôlent l'inverseur.<br /> <br /> === SEMAINE 17 ===<br /> - Concaténation des deux matrices de commande afin d'obtenir une matrice [3x3] pour commande les interrupteurs du convertisseur matriciel.<br /> - Création du schéma final sur Simulink.<br /> [[Fichier:Matric_converter_simulink.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 18 ===<br /> - Réglage des filtres d'entrée et de sortie pour la simulation<br /> - Réglage des différents paramètres des comparateurs hystérésis, three-phase carrier et correcteur P.<br /> <br /> === SEMAINE 19 ===<br /> - Analyse des résultats :<br /> Quelques problèmes au niveau des signaux de sorties. La puissance de référence calculée avec l'inverseur varie beaucoup.<br /> Les courants en sorties de l'inverseur sont bien sinusoïdaux et on observe bien le découpage des signaux sur la figure suivante :<br /> [[Fichier:Courants_de_sortie.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 20 ===<br /> - Préparation du rapport et de la soutenance.<br /> - Réalisation de la vidéo.<br /> <br /> <br /> <br /> == Vidéo ==<br /> Lien Youtube de la vidéo du projet : http://youtu.be/9_q-TNGuCnI<br /> Ou en télechargement sur le wiki <br /> <br /> &lt;td&gt;[[Fichier:PFE.mp4]]&lt;/td&gt;</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=P27_Controle_Direct_de_Puissance_d%27un_Convertisseur_Matriciel&diff=17726 2015-02-24T11:09:09Z

<p>Nalexand : /* Vidéo */</p> <hr /> <div>== Présentation du projet ==<br /> L'objectif de l'étude consiste à élaborer une commande de type DPC (Direct Power Control) pour un<br /> convertisseur matriciel.<br /> <br /> <br /> [[Fichier:Matrix converter DPC.png|upright=4 |thumb|centre]]<br /> <br /> == Prestations attendues ==<br /> Notre travail va se dérouler en plusieurs étapes :<br /> - Etude Bibliographique du convertisseur matriciel et de la commande DPC<br /> - Compréhension et prise en main du contrôle direct sur un redresseur MLI<br /> - Prise en main du convertisseur matriciel et des commandes associées<br /> - Elaboration de la commande DPC pour convertisseur matriciel<br /> - Implantation sous Matlab Simulink<br /> - Simulation de la structure et analyse des résultats<br /> <br /> == Ressources disponibles ==<br /> - Publications de différentes recherches sur le site www.ieee.org<br /> - Modèle Simulink de la commande DPC d'un redresseur MLI<br /> - Modèle Simulink de différentes commandes (autres que DPC) d'un convertisseur matriciel<br /> <br /> == Déroulement du projet ==<br /> <br /> === SEMAINE 1 ===<br /> Prise en main du sujet.<br /> <br /> <br /> === SEMAINE 2 ===<br /> <br /> Rendez-vous réalisé avec notre tuteur, Mr Delarue, celui-ci nous explique le principe général d'un contrôle directe de puissance (DPC), l'avantage que cela représenterai pour les industriels, les moyens d'asservissement de redresseur aujourd'hui.<br /> <br /> Présentation du site IEEE explore, accessible à partir de l'école polytech. Celui-ci permet de trouver différent papier publiés par des chercheurs grâce à un système de mot clés.<br /> <br /> <br /> === SEMAINE 3 ===<br /> Recherche bibliographique sur la DPC (fonctionnement, avantages, utilisation, implémentation,...)<br /> <br /> <br /> === SEMAINE 4 ===<br /> <br /> Recherche bibliographique sur les convertisseur matriciel. (fonctionnement, composition, avantages,...)<br /> Présentation des résultats de nos recherches auprès de notre tuteur.<br /> <br /> <br /> === SEMAINE 5 ===<br /> <br /> Approfondissement de nos recherches, à ce stade nous avons étudier environs une dizaine de rapport de chercheur.<br /> <br /> - Calcul des puissance active et réactive, utilisation des transformée de Park et de Concordia pour trouver les composantes directes et de quadratures des tensions/courants.<br /> <br /> <br /> === SEMAINE 6 ===<br /> <br /> - Soumissions à notre tuteur de plusieurs papier, on choisit de se baser sur l'un d'eux pour comprendre le système proposé et l'implanter sous Matlab<br /> <br /> <br /> === SEMAINE 7 ===<br /> <br /> - étude des comparateurs à hystérésis, ainsi que du régulateur de tension continu du système.<br /> - Prise en main du convertisseur MLI auquel est appliqué une commande DPC sous Matlab (fichier remis par notre tuteur).<br /> <br /> === SEMAINE 8 ===<br /> <br /> - Etude de la table de commutation, des paramètres d'entrée et de sortie.<br /> - Les bits de sortie dépendant des valeurs des deux booléens d'entrée (représentant les erreurs des puissances réactive et actives).<br /> - Les valeurs du tableau reste à définir.<br /> <br /> <br /> === SEMAINE 9 === <br /> - Prise en main du convertisseur matriciel sous Matlab avec la commande DPC, étude de son fonctionnement, de la manière dont il commute. (fichier remis par notre tuteur).<br /> <br /> === SEMAINE 10 ===<br /> - Etude afin d'adapter la commande DPC à un convertisseur matriciel.<br /> - Nous avons obtenus de nombreux papiers de chercheurs sur le site ieee.org, dont un en particulier : <br /> « Direct Power Control Based Matrix Converter and Its Operation Characteristics » <br /> <br /> === SEMAINE 11 ===<br /> - Afin de contrôler le convertisseur matriciel AC/AC, nous allons le décomposer en deux parties : Redresseur (AC/DC) et inverseur (DC/AC).<br /> <br /> [[Fichier:Converter_inverter.png|upright=4 |thumb|centre]]<br /> <br /> - Nous allons étudier la commande de ces deux parties, le redresseur se commande avec le DPC et l'inverseur avec une commande MLI.<br /> <br /> === SEMAINE 12 ===<br /> - Commande DPC du redresseur :<br /> [[Fichier:DPC_converter.png|upright=4 |thumb|centre]]<br /> <br /> - Il faut contrôler les 6 interrupteurs du redresseur à partir d'une table de commutation qui va envoyer 6 signaux (0 ou 1).<br /> - Ces signaux sont obtenus en fonction de la valeur de la puissance instantanée comparée à une puissance de référence.<br /> <br /> === SEMAINE 13 ===<br /> - Réalisation de la commande DPC du redresseur virtuel sur Simulink.<br /> Réalisation de la table de commutation sous forme de fonction Matlab puis sous forme de bloc logique.<br /> <br /> === SEMAINE 14 ===<br /> - Commande MLI de la partie virtuelle inverseur.<br /> [[Fichier:DPC_converter.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 15 ===<br /> - Réalisation de la partie commande de l'inverseur virtuel :<br /> [[Fichier:Virtual_inverter.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 16 ===<br /> - Etude de la partie Latch de la commande de l'inverseur.<br /> Il faut en effet faire attention aux courts-circuits qui peuvent être provoqués lors de la commutation des interrupteurs du redresseur (si Sp et Sq sont tous les deux égaux à 0 en même temps, ce sont les erreurs entre P_inst et P_ref). S'il y a un court-circuit au niveau du bus continu, alors le latch doit bloquer les signaux qui contrôlent l'inverseur.<br /> <br /> === SEMAINE 17 ===<br /> - Concaténation des deux matrices de commande afin d'obtenir une matrice [3x3] pour commande les interrupteurs du convertisseur matriciel.<br /> - Création du schéma final sur Simulink.<br /> [[Fichier:Matric_converter_simulink.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 18 ===<br /> - Réglage des filtres d'entrée et de sortie pour la simulation<br /> - Réglage des différents paramètres des comparateurs hystérésis, three-phase carrier et correcteur P.<br /> <br /> === SEMAINE 19 ===<br /> - Analyse des résultats :<br /> Quelques problèmes au niveau des signaux de sorties. La puissance de référence calculée avec l'inverseur varie beaucoup.<br /> Les courants en sorties de l'inverseur sont bien sinusoïdaux et on observe bien le découpage des signaux sur la figure suivante :<br /> [[Fichier:Courants_de_sortie.png|upright=4 |thumb|centre]]<br /> <br /> === SEMAINE 20 ===<br /> - Préparation du rapport et de la soutenance.<br /> - Réalisation de la vidéo.<br /> <br /> <br /> <br /> == Vidéo ==<br /> Lien Youtube de la vidéo du projet : http://youtu.be/9_q-TNGuCnI<br /> Ou en télechargement sur le wiki &lt;td&gt;[[Fichier:PFE.mp4]]&lt;/td&gt;</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Fichier:PFE.mp4&diff=17724 2015-02-24T11:05:57Z

<p>Nalexand : </p> <hr /> <div></div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=P27_Controle_Direct_de_Puissance_d%27un_Convertisseur_Matriciel&diff=15102 2014-12-16T17:12:17Z

<p>Nalexand : /* SEMAINE 1 */</p> <hr /> <div>== Présentation du projet ==<br /> L'objectif de l'étude consiste à élaborer une commande de type DPC (Direct Power Control) pour un<br /> convertisseur matriciel.<br /> <br /> <br /> [[Fichier:Matrix converter DPC.png|upright=4 |thumb|centre]]<br /> <br /> == Prestations attendues ==<br /> Notre travail va se dérouler en plusieurs étapes :<br /> - Etude Bibliographique du convertisseur matriciel et de la commande DPC<br /> - Compréhension et prise en main du contrôle direct sur un redresseur MLI<br /> - Prise en main du convertisseur matriciel et des commandes associées<br /> - Elaboration de la commande DPC pour convertisseur matriciel<br /> - Implantation sous Matlab Simulink<br /> - Simulation de la structure et analyse des résultats<br /> <br /> == Ressources disponibles ==<br /> - Publications de différentes recherches sur le site www.ieee.org<br /> - Modèle Simulink de la commande DPC d'un redresseur MLI<br /> - Modèle Simulink de différentes commandes (autres que DPC) d'un convertisseur matriciel<br /> <br /> == Déroulement du projet ==<br /> <br /> === SEMAINE 1 ===<br /> Prise en main du sujet.<br /> <br /> <br /> === SEMAINE 2 ===<br /> <br /> Rendez-vous réalisé avec notre tuteur, Mr Delarue, celui-ci nous explique le principe général d'un contrôle directe de puissance (DPC), l'avantage que cela représenterai pour les industriels, les moyens d'asservissement de redresseur aujourd'hui.<br /> <br /> Présentation du site IEEE explore, accessible à partir de l'école polytech. Celui-ci permet de trouver différent papier publiés par des chercheurs grâce à un système de mot clés.<br /> <br /> <br /> === SEMAINE 3 ===<br /> Recherche bibliographique sur la DPC (fonctionnement, avantages, utilisation, implémentation,...)<br /> <br /> <br /> === SEMAINE 4 ===<br /> <br /> Recherche bibliographique sur les convertisseur matriciel. (fonctionnement, composition, avantages,...)<br /> Présentation des résultats de nos recherches auprès de notre tuteur.<br /> <br /> <br /> === SEMAINE 5 ===<br /> <br /> Approfondissement de nos recherches, à ce stade nous avons étudier environs une dizaine de rapport de chercheur.<br /> <br /> - Calcul des puissance active et réactive, utilisation des transformée de Park et de Concordia pour trouver les composantes directes et de quadratures des tensions/courants.<br /> <br /> <br /> === SEMAINE 6 ===<br /> <br /> - Soumissions à notre tuteur de plusieurs papier, on choisit de se baser sur l'un d'eux pour comprendre le système proposé et l'implanter sous Matlab<br /> <br /> <br /> === SEMAINE 7 ===<br /> <br /> - étude des comparateurs à hystérésis, ainsi que du régulateur de tension continu du système.<br /> - Prise en main du convertisseur MLI auquel est appliqué une commande DPC sous matlab (fichier remis par notre tuteur).<br /> <br /> === SEMAINE 8 ===<br /> <br /> - Etude de la table de commutation, des paramètres d'entrée et de sortie.<br /> - Les bits de sortie dépendant des valeurs des deux booleens d'entrée (représentant les erreurs des puissances réactive et actives).<br /> - Les valeurs du tableau reste à définir.<br /> <br /> <br /> === SEMAINE 9 === <br /> - Prise en main du convertisseur matriciel sous Matlab, étude de son fonctionnement, de la manière dont il commute. (fichier remis par notre tuteur).</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=6426 2013-05-24T14:34:18Z

<p>Nalexand : /* Vidéo */</p> <hr /> <div>== Etudiants ==<br /> <br /> <br /> Nicolas Alexandre<br /> Nicolas Leuliet<br /> <br /> == Objectif == <br /> <br /> <br /> L'objectif de ce projet était de faire la simulation 3D du TP palettiseur en Automatique. Il était également possible de rendre en 3D le TP RLI concernant les trains et leurs collisions.<br /> <br /> <br /> == Avancement du projet ==<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 6 :----------------------------------------'''<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 7 :----------------------------------------'''<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> <br /> <br /> <br /> '''----------------------------------------Semaine 8 :----------------------------------------'''<br /> <br /> <br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> '''----------------------------------------Semaine 9 :----------------------------------------'''<br /> <br /> <br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 10 :----------------------------------------'''<br /> <br /> <br /> <br /> Définition des besoins pour le palettiseur :<br /> - Creer des palettes<br /> -Créer des cartons<br /> -Pouvoir tourner les cartons (pince)<br /> -Pouvoir charger les cartons dans les palettes<br /> -Pouvoir expédier le tout<br /> -Communication par réseau UDP<br /> <br /> Recherche de logiciels pouvant créer des objets en 3D et les exportant dans un format compatible avec Unity.<br /> <br /> Les objets à modéliser :<br /> - Cartons<br /> - Palettes<br /> - Tapis Roulants<br /> - Pince<br /> - Plate-forme de chargement<br /> - Trains pour le TP de RLI<br /> <br /> Recherche sur l'envoi et la réception de message provenant du réseau UDP sous Unity<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 11 :----------------------------------------'''<br /> <br /> <br /> <br /> 1 seule séance.<br /> <br /> Après avoir mis en place les scripts de communication sur réseau UDP, on reçoit bien les messages mais problème de communication avec les autres scripts (pour récupérer la variable dans lequel la phrase est réceptionnée.<br /> En parallèle création des premiers éléments physique.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 12 :----------------------------------------'''<br /> <br /> <br /> Résolution du problème de récupération des variables, il fallait importer le script de réception des message dans le script qui le traitera, il faut aussi le placer correctement dans la hiérarchie du projet (&quot;Standars Asset&quot;).<br /> <br /> Définition de la scène, deux tapis roulant amènent la palette et les cartons, les cartons sont chargés dans la palette au niveau de la plateforme et tourné par une pince , un verin pousse la palette pour renvoyer celle-ci sur la chaîne.<br /> <br /> <br /> <br /> '''----------------------------------------Semaines 13-14 :----------------------------------------'''<br /> <br /> <br /> Gestion de la &quot;physique&quot;, ajout de collision entre les différents éléments, ajout de la gravité et du poids des objets.<br /> <br /> Script des tapis roulant mis en place, création des objets par menu ou réseau dans la scène.<br /> <br /> Création des objets 3D : Cartons, palettes tapis roulants.<br /> <br /> <br /> '''----------------------------------------Semaine 15 :----------------------------------------'''<br /> <br /> <br /> <br /> Création de la plateforme de chargement, problème rencontré au niveau de l'expédition de la palette sur la fin de chaîne, pour résoudre cela nous avons changer le procédé, le vérin ramène maintenant la plateforme de chargement ce qui permet à la palette de retourné sur le tapis.<br /> <br /> Ajout de barrière de sécurité au niveau des tapis roulant (ajout de collision dessus) pour empêcher les palettes/cartons de dévier de leurs trajectoires.<br /> <br /> Problème rencontré au niveau de la pince, les carton ne sont pas pris et tournés.<br /> <br /> Ajout des script et boutons arret/marche des tapis<br /> <br /> <br /> '''----------------------------------------Semaine 17 :----------------------------------------''' <br /> <br /> <br /> <br /> Ajout de texture aux différents éléments de la scène, travail sur le rendu visuel.<br /> Ajout des menus et script pour tourner les carton, expédier la palette et réinitialiser la scène.<br /> <br /> Abaissement de la friction au niveau des tapis pour une meilleur &quot;glisse&quot; des objets.<br /> <br /> == Rendu ==<br /> <br /> Voici une capture d'écran du rendu visuel de l'application finale, les scripts ne pouvant être mis ici.<br /> <br /> [[Fichier:Scene unity.jpg]]<br /> <br /> == Rapport ==<br /> <br /> [[Média:Rapport_Simulation_3D.pdf‎]]<br /> <br /> == Fichier à utiliser ==<br /> <br /> Vous trouverez ci-joint les fichiers, modèles 3D et scripts servant à faire fonctionner l'application.<br /> <br /> [[Média:Projet.zip‎]]<br /> <br /> == Vidéo ==<br /> <br /> http://youtu.be/jgM0gC69ONU<br /> <br /> <br /> [[Média:Projet_simulation_3D.zip]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=6425 2013-05-24T14:34:01Z

<p>Nalexand : </p> <hr /> <div>== Etudiants ==<br /> <br /> <br /> Nicolas Alexandre<br /> Nicolas Leuliet<br /> <br /> == Objectif == <br /> <br /> <br /> L'objectif de ce projet était de faire la simulation 3D du TP palettiseur en Automatique. Il était également possible de rendre en 3D le TP RLI concernant les trains et leurs collisions.<br /> <br /> <br /> == Avancement du projet ==<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 6 :----------------------------------------'''<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 7 :----------------------------------------'''<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> <br /> <br /> <br /> '''----------------------------------------Semaine 8 :----------------------------------------'''<br /> <br /> <br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> '''----------------------------------------Semaine 9 :----------------------------------------'''<br /> <br /> <br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 10 :----------------------------------------'''<br /> <br /> <br /> <br /> Définition des besoins pour le palettiseur :<br /> - Creer des palettes<br /> -Créer des cartons<br /> -Pouvoir tourner les cartons (pince)<br /> -Pouvoir charger les cartons dans les palettes<br /> -Pouvoir expédier le tout<br /> -Communication par réseau UDP<br /> <br /> Recherche de logiciels pouvant créer des objets en 3D et les exportant dans un format compatible avec Unity.<br /> <br /> Les objets à modéliser :<br /> - Cartons<br /> - Palettes<br /> - Tapis Roulants<br /> - Pince<br /> - Plate-forme de chargement<br /> - Trains pour le TP de RLI<br /> <br /> Recherche sur l'envoi et la réception de message provenant du réseau UDP sous Unity<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 11 :----------------------------------------'''<br /> <br /> <br /> <br /> 1 seule séance.<br /> <br /> Après avoir mis en place les scripts de communication sur réseau UDP, on reçoit bien les messages mais problème de communication avec les autres scripts (pour récupérer la variable dans lequel la phrase est réceptionnée.<br /> En parallèle création des premiers éléments physique.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 12 :----------------------------------------'''<br /> <br /> <br /> Résolution du problème de récupération des variables, il fallait importer le script de réception des message dans le script qui le traitera, il faut aussi le placer correctement dans la hiérarchie du projet (&quot;Standars Asset&quot;).<br /> <br /> Définition de la scène, deux tapis roulant amènent la palette et les cartons, les cartons sont chargés dans la palette au niveau de la plateforme et tourné par une pince , un verin pousse la palette pour renvoyer celle-ci sur la chaîne.<br /> <br /> <br /> <br /> '''----------------------------------------Semaines 13-14 :----------------------------------------'''<br /> <br /> <br /> Gestion de la &quot;physique&quot;, ajout de collision entre les différents éléments, ajout de la gravité et du poids des objets.<br /> <br /> Script des tapis roulant mis en place, création des objets par menu ou réseau dans la scène.<br /> <br /> Création des objets 3D : Cartons, palettes tapis roulants.<br /> <br /> <br /> '''----------------------------------------Semaine 15 :----------------------------------------'''<br /> <br /> <br /> <br /> Création de la plateforme de chargement, problème rencontré au niveau de l'expédition de la palette sur la fin de chaîne, pour résoudre cela nous avons changer le procédé, le vérin ramène maintenant la plateforme de chargement ce qui permet à la palette de retourné sur le tapis.<br /> <br /> Ajout de barrière de sécurité au niveau des tapis roulant (ajout de collision dessus) pour empêcher les palettes/cartons de dévier de leurs trajectoires.<br /> <br /> Problème rencontré au niveau de la pince, les carton ne sont pas pris et tournés.<br /> <br /> Ajout des script et boutons arret/marche des tapis<br /> <br /> <br /> '''----------------------------------------Semaine 17 :----------------------------------------''' <br /> <br /> <br /> <br /> Ajout de texture aux différents éléments de la scène, travail sur le rendu visuel.<br /> Ajout des menus et script pour tourner les carton, expédier la palette et réinitialiser la scène.<br /> <br /> Abaissement de la friction au niveau des tapis pour une meilleur &quot;glisse&quot; des objets.<br /> <br /> == Rendu ==<br /> <br /> Voici une capture d'écran du rendu visuel de l'application finale, les scripts ne pouvant être mis ici.<br /> <br /> [[Fichier:Scene unity.jpg]]<br /> <br /> == Rapport ==<br /> <br /> [[Média:Rapport_Simulation_3D.pdf‎]]<br /> <br /> == Fichier à utiliser ==<br /> <br /> Vous trouverez ci-joint les fichiers, modèles 3D et scripts servant à faire fonctionner l'application.<br /> <br /> [[Média:Projet.zip‎]]<br /> <br /> == Vidéo ==<br /> <br /> http://youtu.be/jgM0gC69ONU<br /> [[Média:Projet_simulation_3D.zip]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Fichier:Projet_simulation_3D.zip&diff=6424 2013-05-24T14:32:46Z

<p>Nalexand : Vidéo du projet IMA4 Simulation 3D</p> <hr /> <div>Vidéo du projet IMA4 Simulation 3D</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=5931 2013-05-08T19:44:09Z

<p>Nalexand : </p> <hr /> <div>== Etudiants ==<br /> <br /> <br /> Nicolas Alexandre<br /> Nicolas Leuliet<br /> <br /> == Objectif == <br /> <br /> <br /> L'objectif de ce projet était de faire la simulation 3D du TP palettiseur en Automatique. Il était également possible de rendre en 3D le TP RLI concernant les trains et leurs collisions.<br /> <br /> <br /> == Avancement du projet ==<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 6 :----------------------------------------'''<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 7 :----------------------------------------'''<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> <br /> <br /> <br /> '''----------------------------------------Semaine 8 :----------------------------------------'''<br /> <br /> <br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> '''----------------------------------------Semaine 9 :----------------------------------------'''<br /> <br /> <br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 10 :----------------------------------------'''<br /> <br /> <br /> <br /> Définition des besoins pour le palettiseur :<br /> - Creer des palettes<br /> -Créer des cartons<br /> -Pouvoir tourner les cartons (pince)<br /> -Pouvoir charger les cartons dans les palettes<br /> -Pouvoir expédier le tout<br /> -Communication par réseau UDP<br /> <br /> Recherche de logiciels pouvant créer des objets en 3D et les exportant dans un format compatible avec Unity.<br /> <br /> Les objets à modéliser :<br /> - Cartons<br /> - Palettes<br /> - Tapis Roulants<br /> - Pince<br /> - Plate-forme de chargement<br /> - Trains pour le TP de RLI<br /> <br /> Recherche sur l'envoi et la réception de message provenant du réseau UDP sous Unity<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 11 :----------------------------------------'''<br /> <br /> <br /> <br /> 1 seule séance.<br /> <br /> Après avoir mis en place les scripts de communication sur réseau UDP, on reçoit bien les messages mais problème de communication avec les autres scripts (pour récupérer la variable dans lequel la phrase est réceptionnée.<br /> En parallèle création des premiers éléments physique.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 12 :----------------------------------------'''<br /> <br /> <br /> Résolution du problème de récupération des variables, il fallait importer le script de réception des message dans le script qui le traitera, il faut aussi le placer correctement dans la hiérarchie du projet (&quot;Standars Asset&quot;).<br /> <br /> Définition de la scène, deux tapis roulant amènent la palette et les cartons, les cartons sont chargés dans la palette au niveau de la plateforme et tourné par une pince , un verin pousse la palette pour renvoyer celle-ci sur la chaîne.<br /> <br /> <br /> <br /> '''----------------------------------------Semaines 13-14 :----------------------------------------'''<br /> <br /> <br /> Gestion de la &quot;physique&quot;, ajout de collision entre les différents éléments, ajout de la gravité et du poids des objets.<br /> <br /> Script des tapis roulant mis en place, création des objets par menu ou réseau dans la scène.<br /> <br /> Création des objets 3D : Cartons, palettes tapis roulants.<br /> <br /> <br /> '''----------------------------------------Semaine 15 :----------------------------------------'''<br /> <br /> <br /> <br /> Création de la plateforme de chargement, problème rencontré au niveau de l'expédition de la palette sur la fin de chaîne, pour résoudre cela nous avons changer le procédé, le vérin ramène maintenant la plateforme de chargement ce qui permet à la palette de retourné sur le tapis.<br /> <br /> Ajout de barrière de sécurité au niveau des tapis roulant (ajout de collision dessus) pour empêcher les palettes/cartons de dévier de leurs trajectoires.<br /> <br /> Problème rencontré au niveau de la pince, les carton ne sont pas pris et tournés.<br /> <br /> Ajout des script et boutons arret/marche des tapis<br /> <br /> <br /> '''----------------------------------------Semaine 17 :----------------------------------------''' <br /> <br /> <br /> <br /> Ajout de texture aux différents éléments de la scène, travail sur le rendu visuel.<br /> Ajout des menus et script pour tourner les carton, expédier la palette et réinitialiser la scène.<br /> <br /> Abaissement de la friction au niveau des tapis pour une meilleur &quot;glisse&quot; des objets.<br /> <br /> == Rendu ==<br /> <br /> Voici une capture d'écran du rendu visuel de l'application finale, les scripts ne pouvant être mis ici.<br /> <br /> [[Fichier:Scene unity.jpg]]<br /> <br /> == Rapport ==<br /> <br /> [[Média:Rapport_Simulation_3D.pdf‎]]<br /> <br /> == Fichier à utiliser ==<br /> <br /> Vous trouverez ci-joint les fichiers, modèles 3D et scripts servant à faire fonctionner l'application.<br /> <br /> [[Média:Projet.zip‎]]<br /> <br /> == Vidéo ==<br /> <br /> http://youtu.be/jgM0gC69ONU</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=5930 2013-05-08T18:00:22Z

<p>Nalexand : </p> <hr /> <div>== Etudiants ==<br /> <br /> <br /> Nicolas Alexandre<br /> Nicolas Leuliet<br /> <br /> == Objectif == <br /> <br /> <br /> L'objectif de ce projet était de faire la simulation 3D du TP palettiseur en Automatique. Il était également possible de rendre en 3D le TP RLI concernant les trains et leurs collisions.<br /> <br /> <br /> == Avancement du projet ==<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 6 :----------------------------------------'''<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 7 :----------------------------------------'''<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> <br /> <br /> <br /> '''----------------------------------------Semaine 8 :----------------------------------------'''<br /> <br /> <br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> '''----------------------------------------Semaine 9 :----------------------------------------'''<br /> <br /> <br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 10 :----------------------------------------'''<br /> <br /> <br /> <br /> Définition des besoins pour le palettiseur :<br /> - Creer des palettes<br /> -Créer des cartons<br /> -Pouvoir tourner les cartons (pince)<br /> -Pouvoir charger les cartons dans les palettes<br /> -Pouvoir expédier le tout<br /> -Communication par réseau UDP<br /> <br /> Recherche de logiciels pouvant créer des objets en 3D et les exportant dans un format compatible avec Unity.<br /> <br /> Les objets à modéliser :<br /> - Cartons<br /> - Palettes<br /> - Tapis Roulants<br /> - Pince<br /> - Plate-forme de chargement<br /> - Trains pour le TP de RLI<br /> <br /> Recherche sur l'envoi et la réception de message provenant du réseau UDP sous Unity<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 11 :----------------------------------------'''<br /> <br /> <br /> <br /> 1 seule séance.<br /> <br /> Après avoir mis en place les scripts de communication sur réseau UDP, on reçoit bien les messages mais problème de communication avec les autres scripts (pour récupérer la variable dans lequel la phrase est réceptionnée.<br /> En parallèle création des premiers éléments physique.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 12 :----------------------------------------'''<br /> <br /> <br /> Résolution du problème de récupération des variables, il fallait importer le script de réception des message dans le script qui le traitera, il faut aussi le placer correctement dans la hiérarchie du projet (&quot;Standars Asset&quot;).<br /> <br /> Définition de la scène, deux tapis roulant amènent la palette et les cartons, les cartons sont chargés dans la palette au niveau de la plateforme et tourné par une pince , un verin pousse la palette pour renvoyer celle-ci sur la chaîne.<br /> <br /> <br /> <br /> '''----------------------------------------Semaines 13-14 :----------------------------------------'''<br /> <br /> <br /> Gestion de la &quot;physique&quot;, ajout de collision entre les différents éléments, ajout de la gravité et du poids des objets.<br /> <br /> Script des tapis roulant mis en place, création des objets par menu ou réseau dans la scène.<br /> <br /> Création des objets 3D : Cartons, palettes tapis roulants.<br /> <br /> <br /> '''----------------------------------------Semaine 15 :----------------------------------------'''<br /> <br /> <br /> <br /> Création de la plateforme de chargement, problème rencontré au niveau de l'expédition de la palette sur la fin de chaîne, pour résoudre cela nous avons changer le procédé, le vérin ramène maintenant la plateforme de chargement ce qui permet à la palette de retourné sur le tapis.<br /> <br /> Ajout de barrière de sécurité au niveau des tapis roulant (ajout de collision dessus) pour empêcher les palettes/cartons de dévier de leurs trajectoires.<br /> <br /> Problème rencontré au niveau de la pince, les carton ne sont pas pris et tournés.<br /> <br /> Ajout des script et boutons arret/marche des tapis<br /> <br /> <br /> '''----------------------------------------Semaine 17 :----------------------------------------''' <br /> <br /> <br /> <br /> Ajout de texture aux différents éléments de la scène, travail sur le rendu visuel.<br /> Ajout des menus et script pour tourner les carton, expédier la palette et réinitialiser la scène.<br /> <br /> Abaissement de la friction au niveau des tapis pour une meilleur &quot;glisse&quot; des objets.<br /> <br /> == Rendu ==<br /> <br /> Voici une capture d'écran du rendu visuel de l'application finale, les scripts ne pouvant être mis ici.<br /> <br /> [[Fichier:Scene unity.jpg]]<br /> <br /> == Rapport ==<br /> <br /> [[Média:Rapport_Simulation_3D.pdf‎]]<br /> <br /> == Fichier à utiliser ==<br /> <br /> Vous trouverez ci-joint les fichiers, modèles 3D et scripts servant à faire fonctionner l'application.<br /> <br /> [[Média:Projet.zip‎]]<br /> <br /> == Vidéo ==<br /> <br /> http://youtu.be/_S-86Zljq5Q</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=5895 2013-05-07T10:46:35Z

<p>Nalexand : </p> <hr /> <div>'''----------------------------------------Semaine 6 :----------------------------------------'''<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 7 :----------------------------------------'''<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> <br /> <br /> <br /> '''----------------------------------------Semaine 8 :----------------------------------------'''<br /> <br /> <br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> '''----------------------------------------Semaine 9 :----------------------------------------'''<br /> <br /> <br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 10 :----------------------------------------'''<br /> <br /> <br /> <br /> Définition des besoins pour le palettiseur :<br /> - Creer des palettes<br /> -Créer des cartons<br /> -Pouvoir tourner les cartons (pince)<br /> -Pouvoir charger les cartons dans les palettes<br /> -Pouvoir expédier le tout<br /> -Communication par réseau UDP<br /> <br /> Recherche de logiciels pouvant créer des objets en 3D et les exportant dans un format compatible avec Unity.<br /> <br /> Les objets à modéliser :<br /> - Cartons<br /> - Palettes<br /> - Tapis Roulants<br /> - Pince<br /> - Plate-forme de chargement<br /> - Trains pour le TP de RLI<br /> <br /> Recherche sur l'envoi et la réception de message provenant du réseau UDP sous Unity<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 11 :----------------------------------------'''<br /> <br /> <br /> <br /> 1 seule séance.<br /> <br /> Après avoir mis en place les scripts de communication sur réseau UDP, on reçoit bien les messages mais problème de communication avec les autres scripts (pour récupérer la variable dans lequel la phrase est réceptionnée.<br /> En parallèle création des premiers éléments physique.<br /> <br /> <br /> <br /> '''----------------------------------------Semaine 12 :----------------------------------------'''<br /> <br /> <br /> Résolution du problème de récupération des variables, il fallait importer le script de réception des message dans le script qui le traitera, il faut aussi le placer correctement dans la hiérarchie du projet (&quot;Standars Asset&quot;).<br /> <br /> Définition de la scène, deux tapis roulant amènent la palette et les cartons, les cartons sont chargés dans la palette au niveau de la plateforme et tourné par une pince , un verin pousse la palette pour renvoyer celle-ci sur la chaîne.<br /> <br /> <br /> <br /> '''----------------------------------------Semaines 13-14 :----------------------------------------'''<br /> <br /> <br /> Gestion de la &quot;physique&quot;, ajout de collision entre les différents éléments, ajout de la gravité et du poids des objets.<br /> <br /> Script des tapis roulant mis en place, création des objets par menu ou réseau dans la scène.<br /> <br /> Création des objets 3D : Cartons, palettes tapis roulants.<br /> <br /> <br /> '''----------------------------------------Semaine 15 :----------------------------------------'''<br /> <br /> <br /> <br /> Création de la plateforme de chargement, problème rencontré au niveau de l'expédition de la palette sur la fin de chaîne, pour résoudre cela nous avons changer le procédé, le vérin ramène maintenant la plateforme de chargement ce qui permet à la palette de retourné sur le tapis.<br /> <br /> Ajout de barrière de sécurité au niveau des tapis roulant (ajout de collision dessus) pour empêcher les palettes/cartons de dévier de leurs trajectoires.<br /> <br /> Problème rencontré au niveau de la pince, les carton ne sont pas pris et tournés.<br /> <br /> Ajout des script et boutons arret/marche des tapis<br /> <br /> <br /> '''----------------------------------------Semaine 17 :----------------------------------------''' <br /> <br /> <br /> <br /> Ajout de texture aux différents éléments de la scène, travail sur le rendu visuel.<br /> Ajout des menus et script pour tourner les carton, expédier la palette et réinitialiser la scène.<br /> <br /> Abaissement de la friction au niveau des tapis pour une meilleur &quot;glisse&quot; des objets.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=5894 2013-05-07T10:43:19Z

<p>Nalexand : </p> <hr /> <div>'''----------------------------------------Semaine 6 :----------------------------------------'''<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> '''----------------------------------------Semaine 7 :----------------------------------------'''<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> '''----------------------------------------Semaine 8 :----------------------------------------'''<br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> '''----------------------------------------Semaine 9 :----------------------------------------'''<br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.<br /> <br /> '''----------------------------------------Semaine 10 :----------------------------------------'''<br /> <br /> Définition des besoins pour le palettiseur :<br /> - Creer des palettes<br /> -Créer des cartons<br /> -Pouvoir tourner les cartons (pince)<br /> -Pouvoir charger les cartons dans les palettes<br /> -Pouvoir expédier le tout<br /> -Communication par réseau UDP<br /> <br /> Recherche de logiciels pouvant créer des objets en 3D et les exportant dans un format compatible avec Unity.<br /> <br /> Les objets à modéliser :<br /> - Cartons<br /> - Palettes<br /> - Tapis Roulants<br /> - Pince<br /> - Plate-forme de chargement<br /> - Trains pour le TP de RLI<br /> <br /> Recherche sur l'envoi et la réception de message provenant du réseau UDP sous Unity<br /> <br /> '''----------------------------------------Semaine 11 :----------------------------------------'''<br /> <br /> 1 seule séance.<br /> <br /> Après avoir mis en place les scripts de communication sur réseau UDP, on reçoit bien les messages mais problème de communication avec les autres scripts (pour récupérer la variable dans lequel la phrase est réceptionnée.<br /> En parallèle création des premiers éléments physique.<br /> <br /> <br /> '''----------------------------------------Semaine 12 :----------------------------------------'''<br /> Résolution du problème de récupération des variables, il fallait importer le script de réception des message dans le script qui le traitera, il faut aussi le placer correctement dans la hiérarchie du projet (&quot;Standars Asset&quot;).<br /> <br /> Définition de la scène, deux tapis roulant amènent la palette et les cartons, les cartons sont chargés dans la palette au niveau de la plateforme et tourné par une pince , un verin pousse la palette pour renvoyer celle-ci sur la chaîne.<br /> <br /> <br /> '''----------------------------------------Semaines 13-14 :----------------------------------------'''<br /> <br /> Gestion de la &quot;physique&quot;, ajout de collision entre les différents éléments, ajout de la gravité et du poids des objets.<br /> <br /> Script des tapis roulant mis en place, création des objets par menu ou réseau dans la scène.<br /> <br /> Création des objets 3D : Cartons, palettes tapis roulants.<br /> <br /> '''----------------------------------------Semaine 15 :----------------------------------------'''<br /> <br /> Création de la plateforme de chargement, problème rencontré au niveau de l'expédition de la palette sur la fin de chaîne, pour résoudre cela nous avons changer le procédé, le vérin ramène maintenant la plateforme de chargement ce qui permet à la palette de retourné sur le tapis.<br /> <br /> Ajout de barrière de sécurité au niveau des tapis roulant (ajout de collision dessus) pour empêcher les palettes/cartons de dévier de leurs trajectoires.<br /> <br /> Problème rencontré au niveau de la pince, les carton ne sont pas pris et tournés.<br /> <br /> Ajout des script et boutons arret/marche des tapis<br /> <br /> '''----------------------------------------Semaine 17 :----------------------------------------''' <br /> <br /> Ajout de texture aux différents éléments de la scène, travail sur le rendu visuel.<br /> Ajout des menus et script pour tourner les carton, expédier la palette et réinitialiser la scène.<br /> <br /> Abaissement de la friction au niveau des tapis pour une meilleur &quot;glisse&quot; des objets.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=4447 2013-03-07T10:06:53Z

<p>Nalexand : </p> <hr /> <div>'''----------------------------------------Semaine 6 :----------------------------------------'''<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> '''----------------------------------------Semaine 7 :----------------------------------------'''<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> '''----------------------------------------Semaine 8 :----------------------------------------'''<br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> '''----------------------------------------Semaine 9 :----------------------------------------'''<br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=4446 2013-03-07T10:06:24Z

<p>Nalexand : </p> <hr /> <div>''----------------------------------------Semaine 6 :----------------------------------------''<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> ----------------------------------------Semaine 7 :----------------------------------------<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> ----------------------------------------Semaine 8 :----------------------------------------<br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> ----------------------------------------Semaine 9 :----------------------------------------<br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=4445 2013-03-07T10:06:10Z

<p>Nalexand : </p> <hr /> <div>&quot;----------------------------------------Semaine 6 :----------------------------------------&quot;<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> ----------------------------------------Semaine 7 :----------------------------------------<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> ----------------------------------------Semaine 8 :----------------------------------------<br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> ----------------------------------------Semaine 9 :----------------------------------------<br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=4444 2013-03-07T10:05:44Z

<p>Nalexand : </p> <hr /> <div>'----------------------------------------Semaine 6 :----------------------------------------'<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> ----------------------------------------Semaine 7 :----------------------------------------<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> ----------------------------------------Semaine 8 :----------------------------------------<br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> ----------------------------------------Semaine 9 :----------------------------------------<br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Visualisation_3D&diff=4442 2013-03-07T10:05:09Z

<p>Nalexand : Page créée avec « ----------------------------------------Semaine 6 :---------------------------------------- -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour... »</p> <hr /> <div>----------------------------------------Semaine 6 :----------------------------------------<br /> <br /> -Entrevu avec Mr Conrad, définition des objectifs, des logiciels utilisable pour le projets.<br /> <br /> -Objectifs : pouvoir effectuer les fonctions d'ajout, suppression et mouvement d'élément en 3D. Ceux-ci seront commandable par réseau.<br /> <br /> ----------------------------------------Semaine 7 :----------------------------------------<br /> <br /> -Etudes des logiciels : irrlicht, OpenGL, Unity 3D<br /> <br /> Irrlicht : Nombreux tutoriel, licence gratuite, communauté active, accepte un grand nombre de fichier pour modèle 3D.<br /> OpenGL : Beaucoup de possibilité mais plus de code, utilisation de Visual Studio.<br /> Unity 3D : interface simple d'utilisation, quelques tutoriaux, communauté active, accepte un grande nombre de fichier source, utilisation des script simplifiée.<br /> <br /> Notre choix s'est porté sur Unity 3D.<br /> <br /> ----------------------------------------Semaine 8 :----------------------------------------<br /> <br /> Prise en main de Unity 3D, création de la scène, des premiers objets, des points de lumière, gestion des couleurs.<br /> <br /> <br /> ----------------------------------------Semaine 9 :----------------------------------------<br /> <br /> Création de script, les objets (pour l'instant de simple cube) peuvent se déplacer à l'aide de touche sur le clavier, de même pour la caméra.<br /> Suppression des objets possible, de même pour la création.<br /> Création d'un menu pour l'interface utilisateur avec les fonction citées précédemment.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2950 2012-05-27T18:04:45Z

<p>Nalexand : /* Projet accéléromètre */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> Le travail sera réparti au sein du trinôme de la facon suivant<br /> * Partie électronique : Gérôme Monier, Leuliet Nicolas<br /> * Partie informatique : Nicolas Alexandre<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance :<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été téléchargée et inclue dans le fichier htlm.<br /> <br /> <br /> Nous prévoyons donc d'utiliser fichiers 3 pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été remplis même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> * Objectifs de la séances :<br /> ** Finir l'interface<br /> ** Réalisé le programme de récupération de donnée<br /> <br /> <br /> Nous avons donc commencé la séance par la création du programme permettant de récupérer les données de l'accéléromètre avant de les afficher dans le navigateur.<br /> Pour cela nous avons pris exemple sur les programmes mis à disposition sur le site. Comme notre projet ne nécessite pas d'envoyer les des données avec les port série nous avons juste à programmé la partie &quot;réception&quot;.<br /> Le programme fonctionne donc en récupérant les données de initialisant la connexion avec le port série (socket lecture, il faut aussi que le programme demon soit lancé en parallèlement pour que ça fonctionne), il lit ensuite les donnée reçu en intervalles réguliers et si la donnée reçu est différente de la précédent alors le programme l'affiche.<br /> Ce programme est compilé puis rangé dans le dossier /usr/lib/CGI-BIN/<br /> <br /> <br /> Ensuite grâce à la commande Ajax : &quot;new Ajax.Request('fct',{method: 'get',parameters, onSuccess: afficher}&quot;, nous récuperons la valeur afficher par le programme puis nous l'envoyons à la fonction javascript afficher qui s'occupe simplement de changer la value du champ de texte par la donnée récupérer pour que celle-ci s'affiche à l'écran.<br /> <br /> <br /> Les objectifs de cette séance ont été réalisés, nous avons même pu teste l'interface sur l'ordinateur, en lançant le démon d'un coté puis en apuyant sur le bouton Mise en route les valeurs de l'accéléromètre s'afficher bien à l'écran le programme fonctionne donc (après que l'ont ai justement ajouté un intervalle dans fct.c, avant cela le programme ne renvoyé pas de valeur). Pour la prochaine séance il restera donc à installé tout cela sur le FoxBoard.<br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]<br /> <br /> <br /> ===Partie Informatique===<br /> <br /> * Objectifs de cette dernière séance :<br /> ** Paramétrer la Foxboard<br /> ** Envoies des fichiers requis sur la foxboard<br /> ** Relier la FoxBoard et la Nanoboard<br /> <br /> <br /> En nous appuyant sur la page de configuration des foxboard, nous avons pu, avec un eepc, configurer notre Foxboard en modifiant le fichier rootfs/etc/network/interfaces contenu sur la ROM de la Foxboard, celle-ci obtient l'ip 172.26.79.1 qui nous servira pour l'identifier et s'y connecter.<br /> Une fois la carte MSD configurée et replacée dans la Foxboard nous avons pu copier les fichier requis de l'ordinateur vers la Foxboard via la commande &quot;scp -m root@172.26.79.1:&quot;, les fichiers copiés se trouve dans les répertoires suivant :<br /> * /var/www : pour index.php ainsi que la bibliothèque prototypes.js (en plus des sources).<br /> * /usr/lib/CGI-BIN : pour le fichier fct (compilé a partir de la Foxboard en SSH).<br /> * /root/ : le demon permettant de communiquer par le port série(compilé a partir de la Foxboard en SSH).<br /> <br /> Après avoir placé les fichiers on se connecte à la Foxboard par la commande &quot;ssh&quot;, puis après avoir compilé les deux programme C il a fallut modifier le fichier rc.local afin de lancer le démon directement à chaque fois que la board se lance. Enfin pour tester il suffit de se connecter à l'adresse IP 172.26.79.1 sur le navigateur, en branchant la maquette à la Foxboard on voit que l'interface réagit comme avant et donc qu'elle reçoit bien les donnée de l'accéléromètre (assez sensible tout de même il ne faut pas trop le bouger).<br /> <br /> Deux des objectifs de la séance ont été remplis mais la liaison Nanoboard/Foxboard n'a pas pu être réalisé en raison d'une erreur Altium lors de la compilation.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2948 2012-05-27T18:01:47Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance :<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été téléchargée et inclue dans le fichier htlm.<br /> <br /> <br /> Nous prévoyons donc d'utiliser fichiers 3 pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été remplis même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> * Objectifs de la séances :<br /> ** Finir l'interface<br /> ** Réalisé le programme de récupération de donnée<br /> <br /> <br /> Nous avons donc commencé la séance par la création du programme permettant de récupérer les données de l'accéléromètre avant de les afficher dans le navigateur.<br /> Pour cela nous avons pris exemple sur les programmes mis à disposition sur le site. Comme notre projet ne nécessite pas d'envoyer les des données avec les port série nous avons juste à programmé la partie &quot;réception&quot;.<br /> Le programme fonctionne donc en récupérant les données de initialisant la connexion avec le port série (socket lecture, il faut aussi que le programme demon soit lancé en parallèlement pour que ça fonctionne), il lit ensuite les donnée reçu en intervalles réguliers et si la donnée reçu est différente de la précédent alors le programme l'affiche.<br /> Ce programme est compilé puis rangé dans le dossier /usr/lib/CGI-BIN/<br /> <br /> <br /> Ensuite grâce à la commande Ajax : &quot;new Ajax.Request('fct',{method: 'get',parameters, onSuccess: afficher}&quot;, nous récuperons la valeur afficher par le programme puis nous l'envoyons à la fonction javascript afficher qui s'occupe simplement de changer la value du champ de texte par la donnée récupérer pour que celle-ci s'affiche à l'écran.<br /> <br /> <br /> Les objectifs de cette séance ont été réalisés, nous avons même pu teste l'interface sur l'ordinateur, en lançant le démon d'un coté puis en apuyant sur le bouton Mise en route les valeurs de l'accéléromètre s'afficher bien à l'écran le programme fonctionne donc (après que l'ont ai justement ajouté un intervalle dans fct.c, avant cela le programme ne renvoyé pas de valeur). Pour la prochaine séance il restera donc à installé tout cela sur le FoxBoard.<br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]<br /> <br /> <br /> ===Partie Informatique===<br /> <br /> * Objectifs de cette dernière séance :<br /> ** Paramétrer la Foxboard<br /> ** Envoies des fichiers requis sur la foxboard<br /> ** Relier la FoxBoard et la Nanoboard<br /> <br /> <br /> En nous appuyant sur la page de configuration des foxboard, nous avons pu, avec un eepc, configurer notre Foxboard en modifiant le fichier rootfs/etc/network/interfaces contenu sur la ROM de la Foxboard, celle-ci obtient l'ip 172.26.79.1 qui nous servira pour l'identifier et s'y connecter.<br /> Une fois la carte MSD configurée et replacée dans la Foxboard nous avons pu copier les fichier requis de l'ordinateur vers la Foxboard via la commande &quot;scp -m root@172.26.79.1:&quot;, les fichiers copiés se trouve dans les répertoires suivant :<br /> * /var/www : pour index.php ainsi que la bibliothèque prototypes.js (en plus des sources).<br /> * /usr/lib/CGI-BIN : pour le fichier fct (compilé a partir de la Foxboard en SSH).<br /> * /root/ : le demon permettant de communiquer par le port série(compilé a partir de la Foxboard en SSH).<br /> <br /> Après avoir placé les fichiers on se connecte à la Foxboard par la commande &quot;ssh&quot;, puis après avoir compilé les deux programme C il a fallut modifier le fichier rc.local afin de lancer le démon directement à chaque fois que la board se lance. Enfin pour tester il suffit de se connecter à l'adresse IP 172.26.79.1 sur le navigateur, en branchant la maquette à la Foxboard on voit que l'interface réagit comme avant et donc qu'elle reçoit bien les donnée de l'accéléromètre (assez sensible tout de même il ne faut pas trop le bouger).<br /> <br /> Deux des objectifs de la séance ont été remplis mais la liaison Nanoboard/Foxboard n'a pas pu être réalisé en raison d'une erreur Altium lors de la compilation.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2947 2012-05-27T18:00:37Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance :<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> <br /> Nous prévoyons donc d'utiliser fichiers 3 pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été remplis même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> * Objectifs de la séances :<br /> ** Finir l'interface<br /> ** Réalisé le programme de récupération de donnée<br /> <br /> <br /> Nous avons donc commencé la séance par la création du programme permettant de récupérer les données de l'accéléromètre avant de les afficher dans le navigateur.<br /> Pour cela nous avons pris exemple sur les programmes mis à disposition sur le site. Comme notre projet ne nécessite pas d'envoyer les des données avec les port série nous avons juste à programmé la partie &quot;réception&quot;.<br /> Le programme fonctionne donc en récupérant les données de initialisant la connexion avec le port série (socket lecture, il faut aussi que le programme demon soit lancé en parallèlement pour que ça fonctionne), il lit ensuite les donnée reçu en intervalles réguliers et si la donnée reçu est différente de la précédent alors le programme l'affiche.<br /> Ce programme est compilé puis rangé dans le dossier /usr/lib/CGI-BIN/<br /> <br /> <br /> Ensuite grâce à la commande Ajax : &quot;new Ajax.Request('fct',{method: 'get',parameters, onSuccess: afficher}&quot;, nous récuperons la valeur afficher par le programme puis nous l'envoyons à la fonction javascript afficher qui s'occupe simplement de changer la value du champ de texte par la donnée récupérer pour que celle-ci s'affiche à l'écran.<br /> <br /> <br /> Les objectifs de cette séance ont été réalisés, nous avons même pu teste l'interface sur l'ordinateur, en lançant le démon d'un coté puis en apuyant sur le bouton Mise en route les valeurs de l'accéléromètre s'afficher bien à l'écran le programme fonctionne donc (après que l'ont ai justement ajouté un intervalle dans fct.c, avant cela le programme ne renvoyé pas de valeur). Pour la prochaine séance il restera donc à installé tout cela sur le FoxBoard.<br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]<br /> <br /> <br /> ===Partie Informatique===<br /> <br /> * Objectifs de cette dernière séance :<br /> ** Paramétrer la Foxboard<br /> ** Envoies des fichiers requis sur la foxboard<br /> ** Relier la FoxBoard et la Nanoboard<br /> <br /> <br /> En nous appuyant sur la page de configuration des foxboard, nous avons pu, avec un eepc, configurer notre Foxboard en modifiant le fichier rootfs/etc/network/interfaces contenu sur la ROM de la Foxboard, celle-ci obtient l'ip 172.26.79.1 qui nous servira pour l'identifier et s'y connecter.<br /> Une fois la carte MSD configurée et replacée dans la Foxboard nous avons pu copier les fichier requis de l'ordinateur vers la Foxboard via la commande &quot;scp -m root@172.26.79.1:&quot;, les fichiers copiés se trouve dans les répertoires suivant :<br /> * /var/www : pour index.php ainsi que la bibliothèque prototypes.js (en plus des sources).<br /> * /usr/lib/CGI-BIN : pour le fichier fct (compilé a partir de la Foxboard en SSH).<br /> * /root/ : le demon permettant de communiquer par le port série(compilé a partir de la Foxboard en SSH).<br /> <br /> Après avoir placé les fichiers on se connecte à la Foxboard par la commande &quot;ssh&quot;, puis après avoir compilé les deux programme C il a fallut modifier le fichier rc.local afin de lancer le démon directement à chaque fois que la board se lance. Enfin pour tester il suffit de se connecter à l'adresse IP 172.26.79.1 sur le navigateur, en branchant la maquette à la Foxboard on voit que l'interface réagit comme avant et donc qu'elle reçoit bien les donnée de l'accéléromètre (assez sensible tout de même il ne faut pas trop le bouger).<br /> <br /> Deux des objectifs de la séance ont été remplis mais la liaison Nanoboard/Foxboard n'a pas pu être réalisé en raison d'une erreur Altium lors de la compilation.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2946 2012-05-27T18:00:12Z

<p>Nalexand : /* Partie Informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance :<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été remplis même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> * Objectifs de la séances :<br /> ** Finir l'interface<br /> ** Réalisé le programme de récupération de donnée<br /> <br /> <br /> Nous avons donc commencé la séance par la création du programme permettant de récupérer les données de l'accéléromètre avant de les afficher dans le navigateur.<br /> Pour cela nous avons pris exemple sur les programmes mis à disposition sur le site. Comme notre projet ne nécessite pas d'envoyer les des données avec les port série nous avons juste à programmé la partie &quot;réception&quot;.<br /> Le programme fonctionne donc en récupérant les données de initialisant la connexion avec le port série (socket lecture, il faut aussi que le programme demon soit lancé en parallèlement pour que ça fonctionne), il lit ensuite les donnée reçu en intervalles réguliers et si la donnée reçu est différente de la précédent alors le programme l'affiche.<br /> Ce programme est compilé puis rangé dans le dossier /usr/lib/CGI-BIN/<br /> <br /> <br /> Ensuite grâce à la commande Ajax : &quot;new Ajax.Request('fct',{method: 'get',parameters, onSuccess: afficher}&quot;, nous récuperons la valeur afficher par le programme puis nous l'envoyons à la fonction javascript afficher qui s'occupe simplement de changer la value du champ de texte par la donnée récupérer pour que celle-ci s'affiche à l'écran.<br /> <br /> <br /> Les objectifs de cette séance ont été réalisés, nous avons même pu teste l'interface sur l'ordinateur, en lançant le démon d'un coté puis en apuyant sur le bouton Mise en route les valeurs de l'accéléromètre s'afficher bien à l'écran le programme fonctionne donc (après que l'ont ai justement ajouté un intervalle dans fct.c, avant cela le programme ne renvoyé pas de valeur). Pour la prochaine séance il restera donc à installé tout cela sur le FoxBoard.<br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]<br /> <br /> <br /> ===Partie Informatique===<br /> <br /> * Objectifs de cette dernière séance :<br /> ** Paramétrer la Foxboard<br /> ** Envoies des fichiers requis sur la foxboard<br /> ** Relier la FoxBoard et la Nanoboard<br /> <br /> <br /> En nous appuyant sur la page de configuration des foxboard, nous avons pu, avec un eepc, configurer notre Foxboard en modifiant le fichier rootfs/etc/network/interfaces contenu sur la ROM de la Foxboard, celle-ci obtient l'ip 172.26.79.1 qui nous servira pour l'identifier et s'y connecter.<br /> Une fois la carte MSD configurée et replacée dans la Foxboard nous avons pu copier les fichier requis de l'ordinateur vers la Foxboard via la commande &quot;scp -m root@172.26.79.1:&quot;, les fichiers copiés se trouve dans les répertoires suivant :<br /> * /var/www : pour index.php ainsi que la bibliothèque prototypes.js (en plus des sources).<br /> * /usr/lib/CGI-BIN : pour le fichier fct (compilé a partir de la Foxboard en SSH).<br /> * /root/ : le demon permettant de communiquer par le port série(compilé a partir de la Foxboard en SSH).<br /> <br /> Après avoir placé les fichiers on se connecte à la Foxboard par la commande &quot;ssh&quot;, puis après avoir compilé les deux programme C il a fallut modifier le fichier rc.local afin de lancer le démon directement à chaque fois que la board se lance. Enfin pour tester il suffit de se connecter à l'adresse IP 172.26.79.1 sur le navigateur, en branchant la maquette à la Foxboard on voit que l'interface réagit comme avant et donc qu'elle reçoit bien les donnée de l'accéléromètre (assez sensible tout de même il ne faut pas trop le bouger).<br /> <br /> Deux des objectifs de la séance ont été remplis mais la liaison Nanoboard/Foxboard n'a pas pu être réalisé en raison d'une erreur Altium lors de la compilation.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2944 2012-05-27T17:59:28Z

<p>Nalexand : /* Partie Informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance :<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été remplis même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> * Objectifs de la séances :<br /> ** Finir l'interface<br /> ** Réalisé le programme de récupération de donnée<br /> <br /> <br /> Nous avons donc commencé la séance par la création du programme permettant de récupérer les données de l'accéléromètre avant de les afficher dans le navigateur.<br /> Pour cela nous avons pris exemple sur les programmes mis à disposition sur le site. Comme notre projet ne nécessite pas d'envoyer les des données avec les port série nous avons juste à programmé la partie &quot;réception&quot;.<br /> Le programme fonctionne donc en récupérant les données de initialisant la connexion avec le port série (socket lecture, il faut aussi que le programme demon soit lancé en parallèlement pour que ça fonctionne), il lit ensuite les donnée reçu en intervalles réguliers et si la donnée reçu est différente de la précédent alors le programme l'affiche.<br /> Ce programme est compilé puis rangé dans le dossier /usr/lib/CGI-BIN/<br /> <br /> <br /> Ensuite grâce à la commande Ajax : &quot;new Ajax.Request('fct',{method: 'get',parameters, onSuccess: afficher}&quot;, nous récuperons la valeur afficher par le programme puis nous l'envoyons à la fonction javascript afficher qui s'occupe simplement de changer la value du champ de texte par la donnée récupérer pour que celle-ci s'affiche à l'écran.<br /> <br /> <br /> Les objectifs de cette séance ont été réalisés, nous avons même pu teste l'interface sur l'ordinateur, en lançant le démon d'un coté puis en apuyant sur le bouton Mise en route les valeurs de l'accéléromètre s'afficher bien à l'écran le programme fonctionne donc (après que l'ont ai justement ajouté un intervalle dans fct.c, avant cela le programme ne renvoyé pas de valeur). Pour la prochaine séance il restera donc à installé tout cela sur le FoxBoard.<br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]<br /> <br /> <br /> ===Partie Informatique===<br /> <br /> * Objectifs de cette dernière séance :<br /> ** Paramétrer la Foxboard<br /> ** Envoies des fichiers requis sur la foxboard<br /> ** Relier la FoxBoard et la Nanoboard<br /> <br /> <br /> En nous appuyant sur la page de configuration des foxboard, nous avons pu, avec un eepc, configurer notre Foxboard en modifiant le fichier rootfs/etc/network/interfaces contenu sur la ROM de la Foxboard, celle-ci obtient l'ip 172.26.79.1 qui nous servira pour l'identifier et s'y connecter.<br /> Une fois la carte MSD configurée et replacée dans la Foxboard nous avons pu copier les fichier requis de l'ordinateur vers la Foxboard via la commande &quot;scp -m root@172.26.79.1:&quot;, les fichiers copiés se trouve dans les répertoires suivant :<br /> ** /var/www : pour index.php ainsi que la bibliothèque prototypes.js (en plus des sources).<br /> ** /usr/lib/CGI-BIN : pour le fichier fct (compilé a partir de la Foxboard en SSH).<br /> ** /root/ : le demon permettant de communiquer par le port série(compilé a partir de la Foxboard en SSH).<br /> <br /> Après avoir placé les fichiers on se connecte à la Foxboard par la commande &quot;ssh&quot;, puis après avoir compilé les deux programme C il a fallut modifier le fichier rc.local afin de lancer le démon directement à chaque fois que la board se lance. Enfin pour tester il suffit de se connecter à l'adresse IP 172.26.79.1 sur le navigateur, en branchant la maquette à la Foxboard on voit que l'interface réagit comme avant et donc qu'elle reçoit bien les donnée de l'accéléromètre (assez sensible tout de même il ne faut pas trop le bouger).<br /> <br /> Deux des objectifs de la séance ont été remplis mais la liaison Nanoboard/Foxboard n'a pas pu être réalisé en raison d'une erreur Altium lors de la compilation.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2938 2012-05-27T17:41:18Z

<p>Nalexand : /* Partie électronique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance :<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été remplis même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> * Objectifs de la séances :<br /> ** Finir l'interface<br /> ** Réalisé le programme de récupération de donnée<br /> <br /> <br /> Nous avons donc commencé la séance par la création du programme permettant de récupérer les données de l'accéléromètre avant de les afficher dans le navigateur.<br /> Pour cela nous avons pris exemple sur les programmes mis à disposition sur le site. Comme notre projet ne nécessite pas d'envoyer les des données avec les port série nous avons juste à programmé la partie &quot;réception&quot;.<br /> Le programme fonctionne donc en récupérant les données de initialisant la connexion avec le port série (socket lecture, il faut aussi que le programme demon soit lancé en parallèlement pour que ça fonctionne), il lit ensuite les donnée reçu en intervalles réguliers et si la donnée reçu est différente de la précédent alors le programme l'affiche.<br /> Ce programme est compilé puis rangé dans le dossier /usr/lib/CGI-BIN/<br /> <br /> <br /> Ensuite grâce à la commande Ajax : &quot;new Ajax.Request('fct',{method: 'get',parameters, onSuccess: afficher}&quot;, nous récuperons la valeur afficher par le programme puis nous l'envoyons à la fonction javascript afficher qui s'occupe simplement de changer la value du champ de texte par la donnée récupérer pour que celle-ci s'affiche à l'écran.<br /> <br /> <br /> Les objectifs de cette séance ont été réalisés, nous avons même pu teste l'interface sur l'ordinateur, en lançant le démon d'un coté puis en apuyant sur le bouton Mise en route les valeurs de l'accéléromètre s'afficher bien à l'écran le programme fonctionne donc (après que l'ont ai justement ajouté un intervalle dans fct.c, avant cela le programme ne renvoyé pas de valeur). Pour la prochaine séance il restera donc à installé tout cela sur le FoxBoard.<br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]<br /> <br /> <br /> ===Partie Informatique===</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2934 2012-05-27T16:06:44Z

<p>Nalexand : /* Partie Informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance :<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été remplis même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> * Objectifs de la séances :<br /> ** Finir l'interface<br /> ** Réalisé le programme de récupération de donnée<br /> <br /> <br /> Nous avons donc commencé la séance par la création du programme permettant de récupérer les données de l'accéléromètre avant de les afficher dans le navigateur.<br /> Pour cela nous avons pris exemple sur les programmes mis à disposition sur le site. Comme notre projet ne nécessite pas d'envoyer les des données avec les port série nous avons juste à programmé la partie &quot;réception&quot;.<br /> Le programme fonctionne donc en récupérant les données de initialisant la connexion avec le port série (socket lecture, il faut aussi que le programme demon soit lancé en parallèlement pour que ça fonctionne), il lit ensuite les donnée reçu en intervalles réguliers et si la donnée reçu est différente de la précédent alors le programme l'affiche.<br /> Ce programme est compilé puis rangé dans le dossier /usr/lib/CGI-BIN/<br /> <br /> <br /> Ensuite grâce à la commande Ajax : &quot;new Ajax.Request('fct',{method: 'get',parameters, onSuccess: afficher}&quot;, nous récuperons la valeur afficher par le programme puis nous l'envoyons à la fonction javascript afficher qui s'occupe simplement de changer la value du champ de texte par la donnée récupérer pour que celle-ci s'affiche à l'écran.<br /> <br /> <br /> Les objectifs de cette séance ont été réalisés, nous avons même pu teste l'interface sur l'ordinateur, en lançant le démon d'un coté puis en apuyant sur le bouton Mise en route les valeurs de l'accéléromètre s'afficher bien à l'écran le programme fonctionne donc (après que l'ont ai justement ajouté un intervalle dans fct.c, avant cela le programme ne renvoyé pas de valeur). Pour la prochaine séance il restera donc à installé tout cela sur le FoxBoard.<br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2933 2012-05-27T15:46:10Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance :<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été remplis même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> Pour communiquer avec l'accéléromètre il est nécessaire de lancer l’exécutable &quot;demon&quot; qui permet l’accès au port série. <br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2932 2012-05-27T15:45:26Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été remplis même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> Pour communiquer avec l'accéléromètre il est nécessaire de lancer l’exécutable &quot;demon&quot; qui permet l’accès au port série. <br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2931 2012-05-27T15:44:35Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été rempli même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> Pour communiquer avec l'accéléromètre il est nécessaire de lancer l’exécutable &quot;demon&quot; qui permet l’accès au port série. <br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2930 2012-05-27T15:44:18Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> * un fichier index.php pour l'interface.<br /> * un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> * un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été rempli même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> Pour communiquer avec l'accéléromètre il est nécessaire de lancer l’exécutable &quot;demon&quot; qui permet l’accès au port série. <br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2929 2012-05-27T15:43:37Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> ** un fichier index.php pour l'interface.<br /> ** un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> ** un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été rempli même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> Pour communiquer avec l'accéléromètre il est nécessaire de lancer l’exécutable &quot;demon&quot; qui permet l’accès au port série. <br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2928 2012-05-27T15:43:13Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> * Objectifs de la séance<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> ** un fichier index.php pour l'interface.<br /> ** un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> ** un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été rempli même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> Pour communiquer avec l'accéléromètre il est nécessaire de lancer l’exécutable &quot;demon&quot; qui permet l’accès au port série. <br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2927 2012-05-27T15:41:14Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> *Objectifs de la séance :<br /> ** Compréhension du sujet<br /> ** Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> ** Création de l'interface HTML<br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> ** un fichier index.php pour l'interface.<br /> ** un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> ** un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été rempli même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> Pour communiquer avec l'accéléromètre il est nécessaire de lancer l’exécutable &quot;demon&quot; qui permet l’accès au port série. <br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2926 2012-05-27T15:39:44Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>== Evaluation informatique et électronique ==<br /> <br /> === Gestion de projet / rédaction Wiki ===<br /> <br /> Rédaction correcte mais pas très détaillée et incomplète concernant l'informatique.<br /> Rien sur la gestion de projet (pas d'objectifs systématiques, rien sur la répartition du travail).<br /> Note 60% (à revoir si le Wiki est complété).<br /> <br /> === Test fonctionnels ===<br /> <br /> * Sous-système : Sous-système testé du coté informatique. Pas de test FoxBoard / NanoBoard à ma connaissance. Interface primitive qui n'ajoute rien au groupe précédent. Note 75%.<br /> * Système : <br /> <br /> === Qualité de la réalisation ===<br /> <br /> * Informatique :<br /> ** procédure de test : Pas de &lt;tt&gt;README&lt;/tt&gt; sur la FoxBoard.<br /> ** pages HTML et Javascript : <br /> ** scripts PHP ou programmes C :<br /> ** installation sur FoxBoard : Démon lancé au démarrage.<br /> * Electronique :<br /> ** qualité de la réalisation :<br /> ** tests autonomes :<br /> <br /> === Bilan ===<br /> <br /> Tous les points principaux ont un poids équivalent (sauf &quot;système&quot; qui est un bonus).<br /> <br /> Note finale :<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> === '''Séance 1''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> ==== Partie informatique ====<br /> <br /> Objectifs de la séance :<br /> - Compréhension du sujet<br /> - Prise de connaissance des nouveaux langages (Ajax et javascript).<br /> - Création de l'interface HTML<br /> <br /> Le but de la partie informatique est donc de créé une interface html qui récupère les données d'un axe de l’accéléromètre pour ensuite l'afficher sur la page du navigateur.<br /> La page html en question est composé d'un champ de texte dans lequel les données de l'accéléromètre seront affichées, pour l'instant la fonction de récupération des données n'a pas encore été réalisée mais nous avons pu tester la fonction javascript &quot;setTimeout&quot; qui appellera l’exécution du programme C. Cette fonction se déclenche lorsque l'on appuie sur le bouton &quot;Mise en route&quot; présent sur la page, elle nécessite aussi la bibliothèque javascript prototype.js qui a été télécharger et inclue dans le fichier htlm.<br /> <br /> Nous prévoyons donc d'utiliser fichiers pour la partie informatique :<br /> - un fichier index.php pour l'interface.<br /> - un fichier fct.c, le programme permettant de récupérer les données de l'accéléromètre (puis compilé).<br /> - un fichier demon.c, le programme qui initialise le port série nécessaire pour la liaison avec l'accéléromètre (puis compilé).<br /> <br /> Pour cette séance les objectifs ont été rempli même si je n'ai pas pu tester les fonction Ajax (pas de programme de test pour l'instant).<br /> <br /> === '''Séance 2''' ===<br /> <br /> <br /> ==== Partie électronique ====<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> ==== Partie Informatique ====<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> Pour communiquer avec l'accéléromètre il est nécessaire de lancer l’exécutable &quot;demon&quot; qui permet l’accès au port série. <br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> <br /> === '''Séance 3''' ===<br /> <br /> <br /> === Partie électronique ===<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2692 2012-05-24T09:15:01Z

<p>Nalexand : /* Partie Informatique */</p> <hr /> <div>Nicolas Alexandre, Gérôme Monier, Nicolas Leuliet<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> == '''Séance 1''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> == Partie informatique ==<br /> <br /> Pour la partie informatique une page de base en html a été créé. Elle affiche un champ qui se rafraichira automatique grâce notamment à la fonction javascript qui permet de faire appelle à un ensemble de fonction (écrites en C) qui obtiendra des données directement de l’accéléromètre.<br /> <br /> Apprentissage d'Ajax et étude des exemples de programme C de liaison par le port série.<br /> <br /> Les fichiers utilisés sont rajouté dans les répertoire suivant:<br /> <br /> /var/www/ : index_html, prototypes.js<br /> <br /> /usr/lib/CGI-BIN/ : fct (fichier executable permettant de récupérer les données de l'accéléromètre<br /> <br /> == '''Séance 2''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> == Partie Informatique ==<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> Pour communiquer avec l'accéléromètre il est nécessaire de lancer l’exécutable &quot;demon&quot; qui permet l’accès au port série. <br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> == Partie informatique ==<br /> <br /> <br /> == '''Séance 3''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2691 2012-05-24T09:13:25Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>Nicolas Alexandre, Gérôme Monier, Nicolas Leuliet<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> == '''Séance 1''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> == Partie informatique ==<br /> <br /> Pour la partie informatique une page de base en html a été créé. Elle affiche un champ qui se rafraichira automatique grâce notamment à la fonction javascript qui permet de faire appelle à un ensemble de fonction (écrites en C) qui obtiendra des données directement de l’accéléromètre.<br /> <br /> Apprentissage d'Ajax et étude des exemples de programme C de liaison par le port série.<br /> <br /> Les fichiers utilisés sont rajouté dans les répertoire suivant:<br /> <br /> /var/www/ : index_html, prototypes.js<br /> <br /> /usr/lib/CGI-BIN/ : fct (fichier executable permettant de récupérer les données de l'accéléromètre<br /> <br /> == '''Séance 2''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> == Partie Informatique ==<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> == Partie informatique ==<br /> <br /> <br /> == '''Séance 3''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2690 2012-05-24T09:13:04Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>Nicolas Alexandre, Gérôme Monier, Nicolas Leuliet<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> == '''Séance 1''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> == Partie informatique ==<br /> <br /> Pour la partie informatique une page de base en html a été créé. Elle affiche un champ qui se rafraichira automatique grâce notamment à la fonction javascript qui permet de faire appelle à un ensemble de fonction (écrites en C) qui obtiendra des données directement de l’accéléromètre.<br /> <br /> Apprentissage d'Ajax et étude des exemples de programme C de liaison par le port série.<br /> <br /> Les fichiers utilisés sont rajouté dans les répertoire suivant:<br /> /var/www/ : index_html, prototypes.js<br /> <br /> /usr/lib/CGI-BIN/ : fct (fichier executable permettant de récupérer les données de l'accéléromètre<br /> <br /> == '''Séance 2''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> == Partie Informatique ==<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> == Partie informatique ==<br /> <br /> <br /> == '''Séance 3''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2689 2012-05-24T09:12:37Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>Nicolas Alexandre, Gérôme Monier, Nicolas Leuliet<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> == '''Séance 1''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> == Partie informatique ==<br /> <br /> Pour la partie informatique une page de base en html a été créé. Elle affiche un champ qui se rafraichira automatique grâce notamment à la fonction javascript qui permet de faire appelle à un ensemble de fonction (écrites en C) qui obtiendra des données directement de l’accéléromètre.<br /> <br /> Apprentissage d'Ajax et étude des exemples de programme C de liaison par le port série.<br /> <br /> Les fichiers utilisés sont rajouté dans les répertoire suivant:<br /> /var/www/ : index_html, prototypes.js<br /> /usr/lib/CGI-BIN/ : fct (fichier executable permettant de récupérer les données de l'accéléromètre<br /> <br /> == '''Séance 2''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> == Partie Informatique ==<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> == Partie informatique ==<br /> <br /> <br /> == '''Séance 3''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2688 2012-05-24T09:11:52Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>Nicolas Alexandre, Gérôme Monier, Nicolas Leuliet<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> == '''Séance 1''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> == Partie informatique ==<br /> <br /> Pour la partie informatique une page de base en html a été créé. Elle affiche un champ qui se rafraichira automatique grâce notamment à la fonction javascript qui permet de faire appelle à un ensemble de fonction (écrites en C) qui obtiendra des données directement de l’accéléromètre.<br /> <br /> Apprentissage d'Ajax et étude des exemples de programme C de liaison par le port série.<br /> <br /> Les fichiers utilisés sont rajouté dans les répertoire suivant:<br /> /var/www/ : index_html, prototypes.js,<br /> /usr/lib/CGI-BIN/ : fct (fichier executable permettant de récupérer les données de l'accéléromètre<br /> <br /> == '''Séance 2''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> == Partie Informatique ==<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> == Partie informatique ==<br /> <br /> <br /> == '''Séance 3''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2687 2012-05-24T09:08:38Z

<p>Nalexand : /* Partie électronique */</p> <hr /> <div>Nicolas Alexandre, Gérôme Monier, Nicolas Leuliet<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> == '''Séance 1''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> == Partie informatique ==<br /> <br /> Pour la partie informatique une page de base en html a été créé. Elle affiche un champ qui se rafraichira automatique grâce notamment à la fonction javascript qui permet de faire appelle à un ensemble de fonction (écrites en C) qui obtiendra des données directement de l’accéléromètre.<br /> <br /> Apprentissage d'Ajax et étude des exemples de programme C de liaison par le port série.<br /> <br /> (ajouter exemples)<br /> <br /> <br /> == '''Séance 2''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> == Partie Informatique ==<br /> <br /> Au cours de cette seconde séance nous avons réalisé le programme C permettant d'obtenir les informations envoyées par l'accéléromètre, celui-ci récupère une valeur puis l'affiche (par un &quot;printf&quot;), l'utilisation de Ajax et de la bibliothèque prototypes.js (bibliothèque javascript) permet de récupérer ce résultat et de l'afficher directement sur la page web. Un &quot;timer&quot; javascript exécute cette opération toutes les deux secondes à partir du moment où on clique pour la première fois sur &quot;Mise en route&quot;.<br /> <br /> La partie informatique fonctionne bien avec la maquette, il ne reste plus qu'à l'envoyer sur la foxboard pour pouvoir la connecter avec la partie éléctronique.<br /> <br /> == Partie informatique ==<br /> <br /> <br /> == '''Séance 3''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Lors de cette séance, nous avons perfectionné notre FPGA. En effet, l'horloge du compteur et du PWM ne doit pas être la même, contrairement au schéma de la séance précédente (fréquence du PWM doit être 2^5 fois supérieur au compteur). Nous avons choisi 1kHz pour l'horloge du compteur, et 50kHz pour celle du PWM. <br /> Nous observons bien un rapport cyclique de plus en plus faible. Après cette légère modification, nous avons commencé la partie analogique, c'est à dire le filtre passe-bas qui donne la moyenne du signal. Pour ce faire, nous avons choisi un simple circuit RC (avec des valeurs des composants encore perfectibles) afin d'optimiser le filtre. <br /> Pour le comparateur, il s'agit d'un AOP TL 062 qui délivre 0/5V si le signal filtré est supérieur à la tension d'un axe de l'accéléromètre. Ce signal est renvoyé au FPGA qui active la bascule D et ainsi envoie la valeur du compteur. <br /> <br /> [[Fichier:FPGA.png]]<br /> <br /> [[Fichier:Analogique3.png]]</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2526 2012-05-11T15:47:47Z

<p>Nalexand : /* Partie électronique */</p> <hr /> <div>Nicolas Alexandre, Gérôme Monier, Nicolas Leuliet<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> == '''Séance 1''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> == Partie informatique ==<br /> <br /> Pour la partie informatique une page de base en html a été créé. Elle affiche un champ qui se rafraichira automatique grâce notamment à la fonction javascript qui permet de faire appelle à un ensemble de fonction (écrites en C) qui obtiendra des données directement de l’accéléromètre.<br /> <br /> Apprentissage d'Ajax et étude des exemples de programme C de liaison par le port série.<br /> <br /> (ajouter exemples)<br /> <br /> <br /> == '''Séance 2''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> == Partie informatique ==</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2525 2012-05-11T15:47:33Z

<p>Nalexand : /* Partie électronique */</p> <hr /> <div>Nicolas Alexandre, Gérôme Monier, Nicolas Leuliet<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> == '''Séance 1''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM), avec 5 bits de commande. Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable grâce à un compteur. Cette valeur sera ensuite comparée à l'un des trois axes. La partie MLI se fait à l'aide d'Althium 5.<br /> <br /> <br /> == Partie informatique ==<br /> <br /> Pour la partie informatique une page de base en html a été créé. Elle affiche un champ qui se rafraichira automatique grâce notamment à la fonction javascript qui permet de faire appelle à un ensemble de fonction (écrites en C) qui obtiendra des données directement de l’accéléromètre.<br /> <br /> Apprentissage d'Ajax et étude des exemples de programme C de liaison par le port série.<br /> <br /> (ajouter exemples)<br /> <br /> <br /> == '''Séance 2''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Terminer la partie FPGA. Simuler sur la nanoboard avec un analyseur logique. <br /> <br /> A la séance précédente, nous avions commencé la partie sur Althium 5. Cette partie terminée, nous avons effectué les simulations afin de vérifier le bon fonctionnement du schéma (voir ci dessous). Avec l'analyseur numérique, nous avons vérifié les signaux de sorties (la valeur du PWM et du compteur). Il nous reste maintenant la partie analogique, à savoir, le PWM suivi d'un filtre RC et d'un comparateur (servant à comparer les valeurs des tensions des trois axes de l'accéléromètre). Le filtre passe bas nous servira à donner une moyenne de la tension.<br /> [[Fichier:PWM.png]]<br /> <br /> == Partie électronique ==<br /> <br /> == Partie informatique ==</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Communication_s%C3%A9rie,_2011/2012,_TD3&diff=2504 2012-05-11T12:08:32Z

<p>Nalexand : Page créée avec « Bievenue, on a rien fait »</p> <hr /> <div>Bievenue, on a rien fait</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2500 2012-05-11T10:21:31Z

<p>Nalexand : /* Partie informatique */</p> <hr /> <div>Nicolas Alexandre, Gérome Monier, Nicolas Leuliet<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> == '''Séance 1''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM). Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable. Cette valeur sera ensuite comparée à celle de l'un des trois axes.<br /> <br /> <br /> == Partie informatique ==<br /> <br /> Pour la partie informatique une page de base en html a été crée elle affiche un champ qui se rafraichira automatique grâce notamment a la fonction javascript qui permet de faire appelle à un ensemble de fonction (écrites en c) qui obtiendra des données directement de l’accéléromètre.<br /> <br /> Apprentissage d'Ajax et etude des exemples de programme c de liaison par le port série.<br /> <br /> (rajouter exemples)</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Contr%C3%B4le_d%27acc%C3%A9l%C3%A9rom%C3%A8tre,_2011/2012,_TD3&diff=2499 2012-05-11T10:20:59Z

<p>Nalexand : /* Partie électronique */</p> <hr /> <div>Nicolas Alexandre, Gérome Monier, Nicolas Leuliet<br /> <br /> == '''Projet accéléromètre''' ==<br /> <br /> <br /> <br /> '''Objectif du projet''' : Réaliser un sous-système d'acquisition pour accéléromètre. Ainsi, ce sous-système doit être capable de mesurer la vitesse suivant trois axes et de les afficher à l'aide d'une interface Web. La partie informatique de ce projet consistera à traiter les données et les afficher. Celle électronique cherchera à faire la conversion analogique-numérique des signaux des 3 axes.<br /> <br /> <br /> == '''Séance 1''' ==<br /> <br /> <br /> == Partie électronique ==<br /> <br /> Objectif: Analyse du projet, première approche d'Altium 05.<br /> <br /> Après une brève prise en main du logiciel, nous avons commencé à placer les premiers composants qui permettront de réaliser la partie électronique. Pour réaliser un CAN, nous choisissons d'utiliser une MLI (ou PWM). Ainsi, nous pourrons obtenir un signal logique à rapport cyclique variable. Cette valeur sera ensuite comparée à celle de l'un des trois axes.<br /> <br /> <br /> == Partie informatique ==<br /> <br /> Pour la partie informatique une page de base en html a été crée elle affiche un champ qui se rafraichira automatique grâce notamment a la fonction javascript qui permet de faire appelle à un ensemble de fonction (écrites en c) qui obtiendra des données directement de l’accéléromètre.<br /> <br /> Apprentissage d'Ajax et etude des exemples de programme c de liaison par le port série.</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Projets_troisi%C3%A8me_ann%C3%A9e,_2011/2012,_TD3&diff=2279 2012-04-20T12:15:38Z

<p>Nalexand : /* Répartition des binômes */</p> <hr /> <div>== Répartition des binômes ==<br /> <br /> &lt;table border=&quot;1&quot;&gt;<br /> &lt;th&gt;Projet&lt;/th&gt;<br /> &lt;th&gt;Elèves&lt;/th&gt;<br /> &lt;tr&gt;&lt;td&gt;[[Contrôle de matrice leds, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;&lt;FONT COLOR=&quot;blue&quot; &gt;Pour Tetris !&lt;/font&gt; Jean-Marie Vincenti ; Loic Rodriguez ; Bastien Chalaux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Communication série, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Mairesse Pesqueux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Gestion afficheurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Nicolas Husse, Mathieu Lenormand, Matthias Debie&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle LED 256 couleurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Romerowski Kemajou Hossie &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de sonar, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Prénom Nom, ...&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle d'accéléromètre, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Nicolas Leuliet, Nicolas Alexandre, Gérome Monier&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de bras robotique, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;PETITPREZ / [VANDERMEERSCH][http://www.vandermersch.net/] / Lambert / Ribreau&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;/table&gt;</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Projets_troisi%C3%A8me_ann%C3%A9e,_2011/2012,_TD3&diff=2278 2012-04-20T12:13:31Z

<p>Nalexand : /* Répartition des binômes */</p> <hr /> <div>== Répartition des binômes ==<br /> <br /> &lt;table border=&quot;1&quot;&gt;<br /> &lt;th&gt;Projet&lt;/th&gt;<br /> &lt;th&gt;Elèves&lt;/th&gt;<br /> &lt;tr&gt;&lt;td&gt;[[Contrôle de matrice leds, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;&lt;FONT COLOR=&quot;blue&quot; &gt;Pour Tetris !&lt;/font&gt; Jean-Marie Vincenti ; Loic Rodriguez ; Bastien Chalaux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Communication série, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Mairesse Pesqueux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Gestion afficheurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Nicolas Husse, Mathieu Lenormand, Matthias Debie&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle LED 256 couleurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Romerowski Kemajou Hossie &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de sonar, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Prénom Nom, ...&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle d'accéléromètre, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Leuliet Alexandre Monier&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de bras robotique, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;PETITPREZ / [VANDERMEERSCH][http://www.vandermersch.net/] / Lambert / Ribreau&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;/table&gt;</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Projets_troisi%C3%A8me_ann%C3%A9e,_2011/2012,_TD3&diff=2277 2012-04-20T12:12:08Z

<p>Nalexand : /* Répartition des binômes */</p> <hr /> <div>== Répartition des binômes ==<br /> <br /> &lt;table border=&quot;1&quot;&gt;<br /> &lt;th&gt;Projet&lt;/th&gt;<br /> &lt;th&gt;Elèves&lt;/th&gt;<br /> &lt;tr&gt;&lt;td&gt;[[Contrôle de matrice leds, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;&lt;FONT COLOR=&quot;blue&quot; &gt;Pour Tetris !&lt;/font&gt; Jean-Marie Vincenti ; Loic Rodriguez ; Bastien Chalaux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Communication série, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Mairesse&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Gestion afficheurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Nicolas Husse, Mathieu Lenormand, Matthias Debie&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle LED 256 couleurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Romerowski Kemajou Hossie &lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de sonar, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Prénom Nom, ...&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle d'accéléromètre, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Leuliet Alexandre Monier Pesqueux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de bras robotique, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;PETITPREZ / [VANDERMEERSCH][http://www.vandermersch.net/] / Lambert / Ribreau&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;/table&gt;</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Projets_troisi%C3%A8me_ann%C3%A9e,_2011/2012,_TD3&diff=2275 2012-04-20T12:09:47Z

<p>Nalexand : /* Répartition des binômes */</p> <hr /> <div>== Répartition des binômes ==<br /> <br /> &lt;table border=&quot;1&quot;&gt;<br /> &lt;th&gt;Projet&lt;/th&gt;<br /> &lt;th&gt;Elèves&lt;/th&gt;<br /> &lt;tr&gt;&lt;td&gt;[[Contrôle de matrice leds, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;&lt;FONT COLOR=&quot;blue&quot; &gt;Pour Tetris !&lt;/font&gt; Jean-Marie Vincenti ; Loic Rodriguez ; Bastien Chalaux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Communication série, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Prénom Nom, ...&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Gestion afficheurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Nicolas Husse, Mathieu Lenormand, Matthias Debie&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle LED 256 couleurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Romerowski Kemajou Hossie Mairesse&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de sonar, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Prénom Nom, ...&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle d'accéléromètre, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Leuliet Alexandre Monier Pesqueux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de bras robotique, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;PETITPREZ / VANDERMEERSCH / Lambert / Ribreau&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;/table&gt;</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Projets_troisi%C3%A8me_ann%C3%A9e,_2011/2012,_TD3&diff=2273 2012-04-20T12:08:17Z

<p>Nalexand : /* Répartition des binômes */</p> <hr /> <div>== Répartition des binômes ==<br /> <br /> &lt;table border=&quot;1&quot;&gt;<br /> &lt;th&gt;Projet&lt;/th&gt;<br /> &lt;th&gt;Elèves&lt;/th&gt;<br /> &lt;tr&gt;&lt;td&gt;[[Contrôle de matrice leds, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;&lt;FONT COLOR=&quot;blue&quot; &gt;Pour Tetris !&lt;/font&gt; Jean-Marie Vincenti ; Loic Rodriguez ; Bastien Chalaux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Communication série, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Prénom Nom, ...&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Gestion afficheurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Nicolas Husse, Mathieu Lenormand, Matthias Debie&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle LED 256 couleurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Mairesse Nicolas&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de sonar, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Prénom Nom, ...&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle d'accéléromètre, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Leuliet Alexandre Monier Pesqueux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de bras robotique, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;PETITPREZ / VANDERMEERSCH / Lambert / Ribreau&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;/table&gt;</div>

Nalexand https://wiki-ima.plil.fr/mediawiki//index.php?title=Projets_troisi%C3%A8me_ann%C3%A9e,_2011/2012,_TD3&diff=2265 2012-04-20T12:03:03Z

<p>Nalexand : /* Répartition des binômes */</p> <hr /> <div>== Répartition des binômes ==<br /> <br /> &lt;table border=&quot;1&quot;&gt;<br /> &lt;th&gt;Projet&lt;/th&gt;<br /> &lt;th&gt;Elèves&lt;/th&gt;<br /> &lt;tr&gt;&lt;td&gt;[[Contrôle de matrice leds, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Jean-Marie Vincenti ; Loic Rodriguez ; Bastien Chalaux&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Communication série, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Prénom Nom, ...&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Gestion afficheurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Nicolas Husse, Mathieu Lenormand, Matthias Debie&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle LED 256 couleurs, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Prénom Nom, ...&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de sonar, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;Prénom Nom, ...&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle d'accéléromètre, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;ALEXANDRE LEULIET MONIER.&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;tr&gt;<br /> &lt;td&gt;[[Contrôle de bras robotique, 2011/2012, TD3]]&lt;/td&gt;<br /> &lt;td&gt;(PAS: PETITPREZ / VANDERMEERSCH) / Lambert / Ribreau&lt;/td&gt;<br /> &lt;/tr&gt;<br /> &lt;/table&gt;</div>

Nalexand