https://projets-se.plil.fr/mediawiki/api.php?action=feedcontributions&feedformat=atom&user=Skaderisprojets-se.plil.fr - Contributions [fr]2026-05-14T03:43:30ZContributionsMediaWiki 1.39.1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=3171SE4Binome2023-52024-01-18T17:07:18Z<p>Skaderis : /* Clignotement de 2 Leds */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]]<br />
<br />
<br />
<br />
Si vous n'arrivez pas à lire les vidéos du wiki, nous les avons mis dans notre Git avec des Readme pour bien savoir ce qu'elles font et avec le code inséré. Les vidéos sur le git sont de meilleures qualités. <br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici le code qui nous a permis d'endormir les tâches : <syntaxhighlight lang="c" line="1"><br />
for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++) { //on parcourt toutes les tâches, excepté cette de l'attente<br />
<br />
if (taches[cpt].etat == SLEEPY) { //Si on est dans un état de sommeil on décrémente le temps<br />
<br />
taches[cpt].temps--;<br />
<br />
if(taches[cpt].temps <= 0){// si le temps est dépassé, alors on réveille la tâche<br />
<br />
taches[cpt].etat = WAKE;<br />
<br />
}<br />
<br />
}<br />
<br />
}<br />
</syntaxhighlight> <br />
<br />
Voici la fonction que l'on remplacera avec _delay_ms : <br />
<br />
<code>void sleepy(uint16_t timingISR){</code><br />
<br />
<code> cli();</code><br />
<br />
<code> taches[tache_courante].temps = timingISR; //temps = timingISR * 20ms</code> <br />
<br />
<code> taches[tache_courante].etat = SLEEPY;</code> on n'oublie pas de mettre l'état de la tâche en sommeil <br />
<br />
<code> sei();</code><br />
<br />
<code> TIMER1_COMPA_vect();</code><br />
<br />
<code>}</code><br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
[[Fichier:Ordonnancement Leds serie.mov|vignette|ordonnancement Leds avec endormissement|centré]]<br />
<br />
<br />
<br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
[[Fichier:Ordonnancement port serie.mov|centré|vignette|Ordonnancement sur port série]]<br />
=== Conclusion ===<br />
Nous n'avons pas fait tout ce qui avait été demandé mais nous sommes quand même assez content du résultat puisque nous avons un ordonnanceur qui gère à la fois le clignotement de 2 Leds différentes ainsi que la lecture et l'écriture sur le port série. <br />
[[Fichier:Ordinnancement complet.mov|centré|vignette|Ordonnancement des Leds + port série]] <br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
our commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
[[Fichier:Id 1bouton.mov|centré|vignette|Reconnaissance d'1 bouton avec une Led]]Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre carte permet de reconnaître l'appuie sur un bouton <br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée.<br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|Clavier sans appuie sur SHIFT|vignette]]<br />
<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|clavier avec appuie sur SHIFT|vignette|néant]]<br />
<br />
Nous aurions voulu faire un clavier AZERTY mais la matrice n'est pas de la bonne forme.<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. <br />
<br />
Coté carte fille, le bus SPI est utilisé en interruption. Lorsque qu'une donnée est envoyé sur le MOSI, la programme du clavier rentre dans une interruption (ISR) pour renvoyer une info sur le MISO. <br />
<br />
Cela nous permet par exemple d'envoyer une valeur sur le MOSI, et de récupérer une donnée sur le MISO en fonction de la valeur envoyé depuis le MOSI. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre méthode de communication : <br />
[[Fichier:Schéma communication SPI.png|centré|cadre]] <br />
<br />
Lorsque la carte clavier lie une touche, la ligne d'interruption passe à l'état haut. <br />
<br />
La carte mère rentre en interruption et va alors demander quelle carte a déclenché l'interruption. <br />
<br />
Si c'est la carte clavier qui a déclenché l'interruption alors le carte mère demande le nombre de touche à récupérer, puis récupère une a une les touches. <br />
<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide que l'humain qui tape au clavier. <br />
<br />
<br />
Afin de tester notre communication SPI, nous avons utiliser un Arduino uno qui "remplace" la carte mère. et qui envoi les valeurs 0x00, 0x01 ou 0x05, le carte mère à la lecture de la valeur doit répondre par une autre valeur. <br />
<br />
En revanche, après beaucoup de tests non concluant, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérent avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle.<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément notre communication SPI, nous avons utiliser le port série de l'arduino uno pour pouvoir voir les données qui sont envoyé depuis la carte clavier, et ainsi s'assurer que quand on appuie sur une touche du clavier, la carte mère récupère bien le code ASCII de cette touche. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
[[Fichier:Clavier sansINT shift.mp4|centré|vignette|Envoi des boutons lu par SPI]]<br />
<br />
===== Sixième test : identification et bouton =====<br />
Maintenant, puisque l'objectif est d'avoir une communication avec la carte mère, nous avons testé un programme qui envoi la demande d'identification, puis après la réponse, il envoi la demande de bouton. Notre carte clavier répond alors par ces demandes. Nous utilisons toujours une variable globale qui récupère le caractère reçu lorsqu'un bouton a été enfoncé. <br />
<br />
Voici la vidéo de la communication entre le maitre et le clavier : <br />
<br />
[[Fichier:Id bouton.mov|centré|vignette|Identification + bouton avec variable globale]] <br />
<br />
==== Programme final ====<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
[[Fichier:Id touche tampon.mov|centré|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
=== Conclusion ===<br />
Notre carte clavier est capable de lire chacune des touches et associe a chacune d'elle un caractère ASCII. Le clavier possède aussi un système de shift pour pouvoir taper les chiffres de 0 à 9. La précision du clavier n'est pas optimale et va parfois lire 2 fois la même touche quand on appuie sur un bouton. Il faudrait, pour corriger ça, retravailler les différents délais mais nous avons déjà passée pas mal de temps à régler nos délais sans trouver le timing parfait, si il existe.<br />
<br />
Notre bus SPI nous permet d'envoyer les touches du clavier vers la carte mère mais aussi d'identifier la carte clavier. Néanmoins l’ajout de notre système de tampon introduit un décalage d’une touche dans l’envoie des touches que nous avons pas su corriger. <br />
<br />
Les primitives à incorporer dans la carte mère correspondent aux code que nous avons écrit dans l’arduino uno utilisé comme master spi. <br />
<br />
Ce projet nous a permit de parfaitement maîtriser et comprendre la programmation de notre ATmega par AVR ISP (câblage, makefile). Cependant, la programmation par USB aurait était bien plus pratique et nous favoriserons cette méthode à l'avenir. <br />
<br />
Nous sommes tout de même assez content de notre travail puisque nous arrivons à bien envoyer par SPI, que ce soit des lettres (1ère matrice clavier) ou des chiffres (2ème matrice clavier). Nous avons perdu beaucoup de temps sur la gestion du bus SPI à cause notamment des boucliers qui déformaient le signal MISO, mais après des observations à l’oscilloscope nous avons su trouver la cause de notre problème. Nous avons réussi à gérer l'ISR du SPI. Nous nous sommes alors améliorés tous les 2 que ce soit en software ou en hardware.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=3166SE4Binome2023-52024-01-18T17:03:20Z<p>Skaderis : /* Conclusion */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]]<br />
<br />
<br />
<br />
Si vous n'arrivez pas à lire les vidéos du wiki, nous les avons mis dans notre Git avec des Readme pour bien savoir ce qu'elles font et avec le code inséré. Les vidéos sur le git sont de meilleures qualités. <br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici le code qui nous a permis d'endormir les tâches : <br />
<br />
<code>for(uint8_t cpt=1; cpt<TACHE_MAX; cpt++) {</code> on parcourt toutes les tâches, excepté cette de l'attente <br />
<br />
<code>if (taches[cpt].etat == SLEEPY) {</code> Si on est dans un état de sommeil on décrémente le temps <br />
<br />
<code> taches[cpt].temps--;</code><br />
<br />
<code> if(taches[cpt].temps <= 0){</code> si le temps est dépassé, alors on réveille la tâche <br />
<br />
<code> taches[cpt].etat = WAKE;</code><br />
<br />
<code> }</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
Voici la fonction que l'on remplacera avec _delay_ms : <br />
<br />
<code>void sleepy(uint16_t timingISR){</code><br />
<br />
<code> cli();</code><br />
<br />
<code> taches[tache_courante].temps = timingISR; //temps = timingISR * 20ms</code> <br />
<br />
<code> taches[tache_courante].etat = SLEEPY;</code> on n'oublie pas de mettre l'état de la tâche en sommeil <br />
<br />
<code> sei();</code><br />
<br />
<code> TIMER1_COMPA_vect();</code><br />
<br />
<code>}</code><br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
[[Fichier:Ordonnancement Leds serie.mov|vignette|ordonnancement Leds avec endormissement|centré]]<br />
<br />
<br />
<br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
[[Fichier:Ordonnancement port serie.mov|centré|vignette|Ordonnancement sur port série]]<br />
=== Conclusion ===<br />
Nous n'avons pas fait tout ce qui avait été demandé mais nous sommes quand même assez content du résultat puisque nous avons un ordonnanceur qui gère à la fois le clignotement de 2 Leds différentes ainsi que la lecture et l'écriture sur le port série. <br />
<br />
[[Fichier:Ordonnancement Leds portSerie.mp4|centré|vignette|Ordonnancement port série + Leds]]<br />
<br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
our commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
[[Fichier:Id 1bouton.mov|centré|vignette|Reconnaissance d'1 bouton avec une Led]]Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre carte permet de reconnaître l'appuie sur un bouton <br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée.<br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|Clavier sans appuie sur SHIFT|vignette]]<br />
<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|clavier avec appuie sur SHIFT|vignette|néant]]<br />
<br />
Nous aurions voulu faire un clavier AZERTY mais la matrice n'est pas de la bonne forme.<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. <br />
<br />
Coté carte fille, le bus SPI est utilisé en interruption. Lorsque qu'une donnée est envoyé sur le MOSI, la programme du clavier rentre dans une interruption (ISR) pour renvoyer une info sur le MISO. <br />
<br />
Cela nous permet par exemple d'envoyer une valeur sur le MOSI, et de récupérer une donnée sur le MISO en fonction de la valeur envoyé depuis le MOSI. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre méthode de communication : <br />
[[Fichier:Schéma communication SPI.png|centré|cadre]] <br />
<br />
Lorsque la carte clavier lie une touche, la ligne d'interruption passe à l'état haut. <br />
<br />
La carte mère rentre en interruption et va alors demander quelle carte a déclenché l'interruption. <br />
<br />
Si c'est la carte clavier qui a déclenché l'interruption alors le carte mère demande le nombre de touche à récupérer, puis récupère une a une les touches. <br />
<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide que l'humain qui tape au clavier. <br />
<br />
<br />
Afin de tester notre communication SPI, nous avons utiliser un Arduino uno qui "remplace" la carte mère. et qui envoi les valeurs 0x00, 0x01 ou 0x05, le carte mère à la lecture de la valeur doit répondre par une autre valeur. <br />
<br />
En revanche, après beaucoup de tests non concluant, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérent avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle.<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément notre communication SPI, nous avons utiliser le port série de l'arduino uno pour pouvoir voir les données qui sont envoyé depuis la carte clavier, et ainsi s'assurer que quand on appuie sur une touche du clavier, la carte mère récupère bien le code ASCII de cette touche. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
[[Fichier:Clavier sansINT shift.mp4|centré|vignette|Envoi des boutons lu par SPI]]<br />
<br />
===== Sixième test : identification et bouton =====<br />
Maintenant, puisque l'objectif est d'avoir une communication avec la carte mère, nous avons testé un programme qui envoi la demande d'identification, puis après la réponse, il envoi la demande de bouton. Notre carte clavier répond alors par ces demandes. Nous utilisons toujours une variable globale qui récupère le caractère reçu lorsqu'un bouton a été enfoncé. <br />
<br />
Voici la vidéo de la communication entre le maitre et le clavier : <br />
<br />
[[Fichier:Id bouton.mov|centré|vignette|Identification + bouton avec variable globale]] <br />
<br />
==== Programme final ====<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
[[Fichier:Id touche tampon.mov|centré|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
=== Conclusion ===<br />
Notre carte clavier est capable de lire chacune des touches et associe a chacune d'elle un caractère ASCII. Le clavier possède aussi un système de shift pour pouvoir taper les chiffres de 0 à 9. La précision du clavier n'est pas optimale et va parfois lire 2 fois la même touche quand on appuie sur un bouton. Il faudrait, pour corriger ça, retravailler les différents délais mais nous avons déjà passée pas mal de temps à régler nos délais sans trouver le timing parfait, si il existe.<br />
<br />
Notre bus SPI nous permet d'envoyer les touches du clavier vers la carte mère mais aussi d'identifier la carte clavier. Néanmoins l’ajout de notre système de tampon introduit un décalage d’une touche dans l’envoie des touches que nous avons pas su corriger. <br />
<br />
Les primitives à incorporer dans la carte mère correspondent aux code que nous avons écrit dans l’arduino uno utilisé comme master spi. <br />
<br />
Ce projet nous a permit de parfaitement maîtriser et comprendre la programmation de notre ATmega par AVR ISP (câblage, makefile). Cependant, la programmation par USB aurait était bien plus pratique et nous favoriserons cette méthode à l'avenir. <br />
<br />
Nous sommes tout de même assez content de notre travail puisque nous arrivons à bien envoyer par SPI, que ce soit des lettres (1ère matrice clavier) ou des chiffres (2ème matrice clavier). Nous avons perdu beaucoup de temps sur la gestion du bus SPI à cause notamment des boucliers qui déformaient le signal MISO, mais après des observations à l’oscilloscope nous avons su trouver la cause de notre problème. Nous avons réussi à gérer l'ISR du SPI. Nous nous sommes alors améliorés tous les 2 que ce soit en software ou en hardware.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=3162SE4Binome2023-52024-01-18T16:53:33Z<p>Skaderis : /* Conclusion */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]]<br />
<br />
<br />
<br />
Si vous n'arrivez pas à lire les vidéos du wiki, nous les avons mis dans notre Git avec des Readme pour bien savoir ce qu'elles font et avec le code inséré. Les vidéos sur le git sont de meilleures qualités. <br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
[[Fichier:Ordonnancement Leds serie.mov|vignette|ordonnancement Leds avec endormissement|centré]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
[[Fichier:Ordonnancement port serie.mov|centré|vignette|Ordonnancement sur port série]]<br />
=== Conclusion ===<br />
Nous n'avons pas fait tout ce qui avait été demandé mais nous sommes quand même assez content du résultat puisque nous avons un ordonnanceur qui gère à la fois le clignotement de 2 Leds différentes ainsi que la lecture et l'écriture sur le port série. <br />
<br />
[[Fichier:Ordonnancement Leds portSerie.mp4|centré|vignette|Ordonnancement port série + Leds]]<br />
<br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
our commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
[[Fichier:Id 1bouton.mov|centré|vignette|Reconnaissance d'1 bouton avec une Led]]Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre carte permet de reconnaître l'appuie sur un bouton <br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée.<br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|Clavier sans appuie sur SHIFT|vignette]]<br />
<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|clavier avec appuie sur SHIFT|vignette|néant]]<br />
<br />
Nous aurions voulu faire un clavier AZERTY mais la matrice n'est pas de la bonne forme.<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. <br />
<br />
Coté carte fille, le bus SPI est utilisé en interruption. Lorsque qu'une donnée est envoyé sur le MOSI, la programme du clavier rentre dans une interruption (ISR) pour renvoyer une info sur le MISO. <br />
<br />
Cela nous permet par exemple d'envoyer une valeur sur le MOSI, et de récupérer une donnée sur le MISO en fonction de la valeur envoyé depuis le MOSI. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre méthode de communication : <br />
[[Fichier:Schéma communication SPI.png|centré|cadre]] <br />
<br />
Lorsque la carte clavier lie une touche, la ligne d'interruption passe à l'état haut. <br />
<br />
La carte mère rentre en interruption et va alors demander quelle carte a déclenché l'interruption. <br />
<br />
Si c'est la carte clavier qui a déclenché l'interruption alors le carte mère demande le nombre de touche à récupérer, puis récupère une a une les touches. <br />
<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide que l'humain qui tape au clavier. <br />
<br />
<br />
Afin de tester notre communication SPI, nous avons utiliser un Arduino uno qui "remplace" la carte mère. et qui envoi les valeurs 0x00, 0x01 ou 0x05, le carte mère à la lecture de la valeur doit répondre par une autre valeur. <br />
<br />
En revanche, après beaucoup de tests non concluant, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérent avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle.<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément notre communication SPI, nous avons utiliser le port série de l'arduino uno pour pouvoir voir les données qui sont envoyé depuis la carte clavier, et ainsi s'assurer que quand on appuie sur une touche du clavier, la carte mère récupère bien le code ASCII de cette touche. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
[[Fichier:Clavier sansINT shift.mp4|centré|vignette|Envoi des boutons lu par SPI]]<br />
<br />
===== Sixième test : identification et bouton =====<br />
Maintenant, puisque l'objectif est d'avoir une communication avec la carte mère, nous avons testé un programme qui envoi la demande d'identification, puis après la réponse, il envoi la demande de bouton. Notre carte clavier répond alors par ces demandes. Nous utilisons toujours une variable globale qui récupère le caractère reçu lorsqu'un bouton a été enfoncé. <br />
<br />
Voici la vidéo de la communication entre le maitre et le clavier : <br />
<br />
[[Fichier:Id bouton.mov|centré|vignette|Identification + bouton avec variable globale]] <br />
<br />
==== Programme final ====<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
[[Fichier:Id touche tampon.mov|centré|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
=== Conclusion ===<br />
Notre carte clavier est capable de lire chacune des touches et associe a chacune d'elle un caractère ASCII. Le clavier possède aussi un système de shift pour pouvoir taper les chiffres de 0 à 9. La précision du clavier n'est pas optimale et va parfois lire 2 fois la même touche quand on appuie sur un bouton. Il faudrait, pour corriger ça, retravailler les différents délais mais nous avons déjà passée pas mal de temps à régler nos délais sans trouver le timing parfait, si il existe.<br />
<br />
Notre bus SPI nous permet d'envoyer les touches du clavier vers la carte mère mais aussi d'identifier la carte clavier. Néanmoins l’ajout de notre système de tampon introduit un décalage d’une touche dans l’envoie des touches que nous avons pas su corriger. <br />
<br />
Les primitives à incorporer dans la carte mère correspondent aux code que nous avons écrit dans l’arduino uno utilisé comme master spi. <br />
<br />
Nous sommes tout de même assez content de notre travail puisque nous arrivons à bien envoyer par SPI, que ce soit des lettres (1ère matrice clavier) ou des chiffres (2ème matrice clavier). Nous avons perdu beaucoup de temps sur la gestion du bus SPI à cause notamment des boucliers qui déformaient le signal MISO, mais après des observations à l’oscilloscope nous avons su trouver la cause de notre problème. Nous avons réussi à gérer l'ISR du SPI. Nous nous sommes alors améliorés tous les 2 que ce soit en software ou en hardware.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=3153SE4Binome2023-52024-01-18T16:42:53Z<p>Skaderis : /* Sixième test : identification et bouton */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]]<br />
<br />
<br />
<br />
Si vous n'arrivez pas à lire les vidéos du wiki, nous les avons mis dans notre Git avec des Readme pour bien savoir ce qu'elles font et avec le code inséré. Les vidéos sur le git sont de meilleures qualités. <br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
[[Fichier:Ordonnancement Leds serie.mov|vignette|ordonnancement Leds avec endormissement|centré]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
[[Fichier:Ordonnancement port serie.mov|centré|vignette|Ordonnancement sur port série]]<br />
=== Conclusion ===<br />
Nous n'avons pas fait tout ce qui avait été demandé mais nous sommes quand même assez content du résultat puisque nous avons un ordonnanceur qui gère à la fois le clignotement de 2 Leds différentes ainsi que la lecture et l'écriture sur le port série. <br />
<br />
[[Fichier:Ordonnancement Leds portSerie.mp4|centré|vignette|Ordonnancement port série + Leds]]<br />
<br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
our commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
[[Fichier:Id 1bouton.mov|centré|vignette|Reconnaissance d'1 bouton avec une Led]]Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre carte permet de reconnaître l'appuie sur un bouton <br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée.<br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|Clavier sans appuie sur SHIFT|vignette]]<br />
<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|clavier avec appuie sur SHIFT|vignette|néant]]<br />
<br />
Nous aurions voulu faire un clavier AZERTY mais la matrice n'est pas de la bonne forme.<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. <br />
<br />
Coté carte fille, le bus SPI est utilisé en interruption. Lorsque qu'une donnée est envoyé sur le MOSI, la programme du clavier rentre dans une interruption (ISR) pour renvoyer une info sur le MISO. <br />
<br />
Cela nous permet par exemple d'envoyer une valeur sur le MOSI, et de récupérer une donnée sur le MISO en fonction de la valeur envoyé depuis le MOSI. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre méthode de communication : <br />
[[Fichier:Schéma communication SPI.png|centré|cadre]] <br />
<br />
Lorsque la carte clavier lie une touche, la ligne d'interruption passe à l'état haut. <br />
<br />
La carte mère rentre en interruption et va alors demander quelle carte a déclenché l'interruption. <br />
<br />
Si c'est la carte clavier qui a déclenché l'interruption alors le carte mère demande le nombre de touche à récupérer, puis récupère une a une les touches. <br />
<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide que l'humain qui tape au clavier. <br />
<br />
<br />
Afin de tester notre communication SPI, nous avons utiliser un Arduino uno qui "remplace" la carte mère. et qui envoi les valeurs 0x00, 0x01 ou 0x05, le carte mère à la lecture de la valeur doit répondre par une autre valeur. <br />
<br />
En revanche, après beaucoup de tests non concluant, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérent avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle.<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément notre communication SPI, nous avons utiliser le port série de l'arduino uno pour pouvoir voir les données qui sont envoyé depuis la carte clavier, et ainsi s'assurer que quand on appuie sur une touche du clavier, la carte mère récupère bien le code ASCII de cette touche. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
[[Fichier:Clavier sansINT shift.mp4|centré|vignette|Envoi des boutons lu par SPI]]<br />
<br />
===== Sixième test : identification et bouton =====<br />
Maintenant, puisque l'objectif est d'avoir une communication avec la carte mère, nous avons testé un programme qui envoi la demande d'identification, puis après la réponse, il envoi la demande de bouton. Notre carte clavier répond alors par ces demandes. Nous utilisons toujours une variable globale qui récupère le caractère reçu lorsqu'un bouton a été enfoncé. <br />
<br />
Voici la vidéo de la communication entre le maitre et le clavier : <br />
<br />
Programme final<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
[[Fichier:Id touche tampon.mov|centré|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
=== Conclusion ===<br />
Notre carte clavier est capable de lire chacune des touches et associe a chacune d'elle un caractère ASCII. Le clavier possède aussi un système de shift pour pouvoir taper les chiffres de 0 à 9. La précision du clavier n'est pas optimale et va parfois lire 2 fois la même touche quand on appuie sur un bouton. Il faudrait, pour corriger ça, retravailler les différents délais mais nous avons déjà passée pas mal de temps à régler nos délais sans trouver le timing parfait, si il existe.<br />
<br />
Notre bus SPI nous permet d'envoyer les touches du clavier vers la carte mère mais aussi d'identifier la carte clavier. <br />
<br />
Nous sommes tout de même assez content de notre travail puisque nous arrivons à bien envoyer par SPI, que ce soit des lettres (1ère matrice) ou des chiffres (2ème matrice). Nous avons pris pas mal de temps à gérer la gestion de la matrice de boutons et avons finalement réussi, nous avons réussi à gérer l'ISR et aussi le bus SPI. Nous nous sommes alors améliorés tous les 2 que ce soit en software ou en hardware.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=3149SE4Binome2023-52024-01-18T16:41:42Z<p>Skaderis : /* Sixième test : identification et bouton */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]]<br />
<br />
<br />
<br />
Si vous n'arrivez pas à lire les vidéos du wiki, nous les avons mis dans notre Git avec des Readme pour bien savoir ce qu'elles font et avec le code inséré. Les vidéos sur le git sont de meilleures qualités. <br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
[[Fichier:Ordonnancement Leds serie.mov|vignette|ordonnancement Leds avec endormissement|centré]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
[[Fichier:Ordonnancement port serie.mov|centré|vignette|Ordonnancement sur port série]]<br />
=== Conclusion ===<br />
Nous n'avons pas fait tout ce qui avait été demandé mais nous sommes quand même assez content du résultat puisque nous avons un ordonnanceur qui gère à la fois le clignotement de 2 Leds différentes ainsi que la lecture et l'écriture sur le port série. <br />
<br />
[[Fichier:Ordonnancement Leds portSerie.mp4|centré|vignette|Ordonnancement port série + Leds]]<br />
<br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
our commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
[[Fichier:Id 1bouton.mov|centré|vignette|Reconnaissance d'1 bouton avec une Led]]Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre carte permet de reconnaître l'appuie sur un bouton <br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée.<br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|Clavier sans appuie sur SHIFT|vignette]]<br />
<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|clavier avec appuie sur SHIFT|vignette|néant]]<br />
<br />
Nous aurions voulu faire un clavier AZERTY mais la matrice n'est pas de la bonne forme.<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. <br />
<br />
Coté carte fille, le bus SPI est utilisé en interruption. Lorsque qu'une donnée est envoyé sur le MOSI, la programme du clavier rentre dans une interruption (ISR) pour renvoyer une info sur le MISO. <br />
<br />
Cela nous permet par exemple d'envoyer une valeur sur le MOSI, et de récupérer une donnée sur le MISO en fonction de la valeur envoyé depuis le MOSI. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre méthode de communication : <br />
[[Fichier:Schéma communication SPI.png|centré|cadre]] <br />
<br />
Lorsque la carte clavier lie une touche, la ligne d'interruption passe à l'état haut. <br />
<br />
La carte mère rentre en interruption et va alors demander quelle carte a déclenché l'interruption. <br />
<br />
Si c'est la carte clavier qui a déclenché l'interruption alors le carte mère demande le nombre de touche à récupérer, puis récupère une a une les touches. <br />
<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide que l'humain qui tape au clavier. <br />
<br />
<br />
Afin de tester notre communication SPI, nous avons utiliser un Arduino uno qui "remplace" la carte mère. et qui envoi les valeurs 0x00, 0x01 ou 0x05, le carte mère à la lecture de la valeur doit répondre par une autre valeur. <br />
<br />
En revanche, après beaucoup de tests non concluant, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérent avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle.<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément notre communication SPI, nous avons utiliser le port série de l'arduino uno pour pouvoir voir les données qui sont envoyé depuis la carte clavier, et ainsi s'assurer que quand on appuie sur une touche du clavier, la carte mère récupère bien le code ASCII de cette touche. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
[[Fichier:Clavier sansINT shift.mp4|centré|vignette|Envoi des boutons lu par SPI]]<br />
<br />
===== Sixième test : identification et bouton =====<br />
Maintenant, puisque l'objectif est d'avoir une communication avec la carte mère, nous avons testé un programme qui envoi la demande d'identification, puis après la réponse, il envoi la demande de bouton. Notre carte clavier répond alors par ces demandes. Nous utilisons toujours une variable globale qui récupère le caractère reçu lorsqu'un bouton a été enfoncé. <br />
<br />
Voici la vidéo de la communication entre le maitre et le clavier : <br />
[[Fichier:ID+lettre Variableglobal.mp4|centré|vignette]]<br />
Programme final<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
[[Fichier:Id touche tampon.mov|centré|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
=== Conclusion ===<br />
Notre carte clavier est capable de lire chacune des touches et associe a chacune d'elle un caractère ASCII. Le clavier possède aussi un système de shift pour pouvoir taper les chiffres de 0 à 9. La précision du clavier n'est pas optimale et va parfois lire 2 fois la même touche quand on appuie sur un bouton. Il faudrait, pour corriger ça, retravailler les différents délais mais nous avons déjà passée pas mal de temps à régler nos délais sans trouver le timing parfait, si il existe.<br />
<br />
Notre bus SPI nous permet d'envoyer les touches du clavier vers la carte mère mais aussi d'identifier la carte clavier. <br />
<br />
Nous sommes tout de même assez content de notre travail puisque nous arrivons à bien envoyer par SPI, que ce soit des lettres (1ère matrice) ou des chiffres (2ème matrice). Nous avons pris pas mal de temps à gérer la gestion de la matrice de boutons et avons finalement réussi, nous avons réussi à gérer l'ISR et aussi le bus SPI. Nous nous sommes alors améliorés tous les 2 que ce soit en software ou en hardware.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:ID%2Blettre_Variableglobal.mp4&diff=3148Fichier:ID+lettre Variableglobal.mp42024-01-18T16:41:11Z<p>Skaderis : </p>
<hr />
<div>demonstration vidéo</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=3142SE4Binome2023-52024-01-18T16:32:12Z<p>Skaderis : /* Troisième test : lecture de tous les boutons + shift */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]]<br />
<br />
<br />
<br />
Si vous n'arrivez pas à lire les vidéos du wiki, nous les avons mis dans notre Git avec des Readme pour bien savoir ce qu'elles font et avec le code inséré. Les vidéos sur le git sont de meilleures qualités. <br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
[[Fichier:Ordonnancement Leds serie.mov|vignette|ordonnancement Leds avec endormissement|centré]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
[[Fichier:Ordonnancement port serie.mov|centré|vignette|Ordonnancement sur port série]]<br />
=== Conclusion ===<br />
Nous n'avons pas fait tout ce qui avait été demandé mais nous sommes quand même assez content du résultat puisque nous avons un ordonnanceur qui gère à la fois le clignotement de 2 Leds différentes ainsi que la lecture et l'écriture sur le port série. <br />
<br />
[[Fichier:Ordonnancement Leds portSerie.mp4|centré|vignette|Ordonnancement port série + Leds]]<br />
<br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
our commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
[[Fichier:Id 1bouton.mov|centré|vignette|Reconnaissance d'1 bouton avec une Led]]Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre carte permet de reconnaître l'appuie sur un bouton <br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée.<br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|Clavier sans appuie sur SHIFT|vignette]]<br />
<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|clavier avec appuie sur SHIFT|vignette|néant]]<br />
<br />
Nous aurions voulu faire un clavier AZERTY mais la matrice n'est pas de la bonne forme.<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. <br />
<br />
Coté carte fille, le bus SPI est utilisé en interruption. Lorsque qu'une donnée est envoyé sur le MOSI, la programme du clavier rentre dans une interruption (ISR) pour renvoyer une info sur le MISO. <br />
<br />
Cela nous permet par exemple d'envoyer une valeur sur le MOSI, et de récupérer une donnée sur le MISO en fonction de la valeur envoyé depuis le MOSI. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre méthode de communication : <br />
[[Fichier:Schéma communication SPI.png|centré|cadre]] <br />
<br />
Lorsque la carte clavier lie une touche, la ligne d'interruption passe à l'état haut. <br />
<br />
La carte mère rentre en interruption et va alors demander quelle carte a déclenché l'interruption. <br />
<br />
Si c'est la carte clavier qui a déclenché l'interruption alors le carte mère demande le nombre de touche à récupérer, puis récupère une a une les touches. <br />
<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide que l'humain qui tape au clavier. <br />
<br />
<br />
Afin de tester notre communication SPI, nous avons utiliser un Arduino uno qui "remplace" la carte mère. et qui envoi les valeurs 0x00, 0x01 ou 0x05, le carte mère à la lecture de la valeur doit répondre par une autre valeur. <br />
<br />
En revanche, après beaucoup de tests non concluant, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérent avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle.<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément notre communication SPI, nous avons utiliser le port série de l'arduino uno pour pouvoir voir les données qui sont envoyé depuis la carte clavier, et ainsi s'assurer que quand on appuie sur une touche du clavier, la carte mère récupère bien le code ASCII de cette touche. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
[[Fichier:Clavier sansINT shift.mp4|centré|vignette|Envoi des boutons lu par SPI]]<br />
=== Programme final ===<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
[[Fichier:Id touche tampon.mov|centré|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
=== Conclusion ===<br />
Notre carte clavier est capable de lire chacune des touches et associe a chacune d'elle un caractère ASCII. Le clavier possède aussi un système de shift pour pouvoir taper les chiffres de 0 à 9. La précision du clavier n'est pas optimale et va parfois lire 2 fois la même touche quand on appuie sur un bouton. Il faudrait pour corriger ça retravailler les différents délais mais nous avons déjà passée pas mal de temps à régler nos délais sans trouver le timing parfait si il existe.<br />
<br />
Notre bus SPI nous permet d'envoyer les touches du clavier vers la carte mère et d'identifier la carte clavier.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=3141SE4Binome2023-52024-01-18T16:31:27Z<p>Skaderis : /* Quatrième test : le bus SPI */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]]<br />
<br />
<br />
<br />
Si vous n'arrivez pas à lire les vidéos du wiki, nous les avons mis dans notre Git avec des Readme pour bien savoir ce qu'elles font et avec le code inséré. Les vidéos sur le git sont de meilleures qualités. <br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
[[Fichier:Ordonnancement Leds serie.mov|vignette|ordonnancement Leds avec endormissement|centré]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
[[Fichier:Ordonnancement port serie.mov|centré|vignette|Ordonnancement sur port série]]<br />
=== Conclusion ===<br />
Nous n'avons pas fait tout ce qui avait été demandé mais nous sommes quand même assez content du résultat puisque nous avons un ordonnanceur qui gère à la fois le clignotement de 2 Leds différentes ainsi que la lecture et l'écriture sur le port série. <br />
<br />
[[Fichier:Ordonnancement Leds portSerie.mp4|centré|vignette|Ordonnancement port série + Leds]]<br />
<br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
our commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
[[Fichier:Id 1bouton.mov|centré|vignette|Reconnaissance d'1 bouton avec une Led]]Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre carte permet de reconnaître l'appuie sur un bouton <br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée.<br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|Clavier sans appuie sur SHIFT|vignette]]<br />
<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|clavier avec appuie sur SHIFT|vignette|néant]]<br />
<br />
Nous aurions voulu faire un clavier AZERTY mais la matrice n'est pas de la bonne forme.<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. <br />
<br />
Coté carte fille, le bus SPI est utilisé en interruption. Lorsque qu'une donnée est envoyé sur le MOSI, la programme du clavier rentre dans une interruption (ISR) pour renvoyer une info sur le MISO. <br />
<br />
Cela nous permet par exemple d'envoyer une valeur sur le MOSI, et de récupérer une donnée sur le MISO en fonction de la valeur envoyé depuis le MOSI. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre méthode de communication : <br />
[[Fichier:Schéma communication SPI.png|centré|cadre]] <br />
<br />
Lorsque la carte clavier lie une touche, la ligne d'interruption passe à l'état haut. <br />
<br />
La carte mère rentre en interruption et va alors demander quelle carte a déclenché l'interruption. <br />
<br />
Si c'est la carte clavier qui a déclenché l'interruption alors le carte mère demande le nombre de touche à récupérer, puis récupère une a une les touches. <br />
<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide que l'humain qui tape au clavier. <br />
<br />
<br />
Afin de tester notre communication SPI, nous avons utiliser un Arduino uno qui "remplace" la carte mère. et qui envoi les valeurs 0x00, 0x01 ou 0x05, le carte mère à la lecture de la valeur doit répondre par une autre valeur. <br />
<br />
En revanche, après beaucoup de tests non concluant, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérent avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle.<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
<br />
[[Fichier:Clavier sansINT shift.mp4|centré|vignette|Envoi des boutons lu par SPI]] <br />
<br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément notre communication SPI, nous avons utiliser le port série de l'arduino uno pour pouvoir voir les données qui sont envoyé depuis la carte clavier, et ainsi s'assurer que quand on appuie sur une touche du clavier, la carte mère récupère bien le code ASCII de cette touche. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
=== Programme final ===<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
[[Fichier:Id touche tampon.mov|centré|cadre]]<br />
<br />
<br />
<br />
<br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
=== Conclusion ===<br />
Notre carte clavier est capable de lire chacune des touches et associe a chacune d'elle un caractère ASCII. Le clavier possède aussi un système de shift pour pouvoir taper les chiffres de 0 à 9. La précision du clavier n'est pas optimale et va parfois lire 2 fois la même touche quand on appuie sur un bouton. Il faudrait pour corriger ça retravailler les différents délais mais nous avons déjà passée pas mal de temps à régler nos délais sans trouver le timing parfait si il existe.<br />
<br />
Notre bus SPI nous permet d'envoyer les touches du clavier vers la carte mère et d'identifier la carte clavier.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=3092SE4Binome2023-52024-01-18T15:48:06Z<p>Skaderis : /* Points importants à savoir */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code> <br />
<br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
our commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]] <br />
<br />
VIDEO TEST BOUTON <br />
<br />
Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre carte permet de reconnaître l'appuie sur un bouton <br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée.<br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|cadre|Clavier sans appuie sur SHIFT]]<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|centré|cadre|clavier avec appuie sur SHIFT]]<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. <br />
<br />
Coté carte fille, le bus SPI est utilisé en interruption. Lorsque qu'une donnée est envoyé sur le MOSI, la programme du clavier rentre dans une interruption (ISR) pour renvoyer une info sur le MISO. <br />
<br />
Cela nous permet par exemple d'envoyer une valeur sur le MOSI, et de récupérer une donnée sur le MISO en fonction de la valeur envoyé depuis le MOSI. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre méthode de communication : <br />
[[Fichier:Schéma communication SPI.png|centré|cadre]] <br />
<br />
Lorsque la carte clavier lie une touche, la ligne d'interruption passe à l'état haut. <br />
<br />
La carte mère rentre en interruption et va alors demander quelle carte a déclenché l'interruption. <br />
<br />
Si c'est la carte clavier qui a déclenché l'interruption alors le carte mère demande le nombre de touche à récupérer, puis récupère une a une les touches. <br />
<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide que l'humain qui tape au clavier. <br />
<br />
<br />
Afin de tester notre communication SPI, nous avons utiliser un Arduino uno qui "remplace" la carte mère. et qui envoi les valeurs 0x00, 0x01 ou 0x05, le carte mère à la lecture de la valeur doit répondre par une autre valeur. <br />
<br />
En revanche, après beaucoup de tests non concluant, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérent avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle.<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
<br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément notre communication SPI, nous avons utiliser le port série de l'arduino uno pour pouvoir voir les données qui sont envoyé depuis la carte clavier, et ainsi s'assurer que quand on appuie sur une touche du clavier, la carte mère récupère bien le code ASCII de cette touche. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
Voici la vidéo montrant le fonctionnement de notre clavier : <br />
<br />
<br />
<big>VIDEO</big> <br />
<br />
=== Programme final ===<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
[[Fichier:Id touche tampon.mov|centré|cadre]]<br />
<br />
<br />
<big>VIDEO</big><br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
=== Conclusion ===<br />
Notre carte clavier est capable de lire chacune des touches et associe a chacune d'elle un caractère ASCII. Le clavier possède aussi un système de shift pour pouvoir taper les chiffres de 0 à 9. La précision du clavier n'est pas optimale et va parfois lire 2 fois la même touche quand on appuie sur un bouton. Il faudrait pour corriger ça retravailler les différents délais mais nous avons déjà passée pas mal de temps à régler nos délais sans trouver le timing parfait si il existe.<br />
<br />
Notre bus SPI nous permet d'envoyer les touches du clavier vers la carte mère et d'identifier la carte clavier.<br />
<br />
==== Différentes vidéos ====</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=3084SE4Binome2023-52024-01-18T15:35:34Z<p>Skaderis : /* Deuxième test : la lecture d'un bouton */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code> <br />
<br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
our commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]] <br />
<br />
VIDEO TEST BOUTON <br />
<br />
Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre carte permet de reconnaître l'appuie sur un bouton <br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée.<br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|cadre|Clavier sans appuie sur SHIFT]]<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|centré|cadre|clavier avec appuie sur SHIFT]]<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. <br />
<br />
Coté carte fille, le bus SPI est utilisé en interruption. Lorsque qu'une donnée est envoyé sur le MOSI, la programme du clavier rentre dans une interruption (ISR) pour renvoyer une info sur le MISO. <br />
<br />
Cela nous permet par exemple d'envoyer une valeur sur le MOSI, et de récupérer une donnée sur le MISO en fonction de la valeur envoyé depuis le MOSI. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre méthode de communication : <br />
[[Fichier:Schéma communication SPI.png|centré|cadre]] <br />
<br />
Lorsque la carte clavier lie une touche, la ligne d'interruption passe à l'état haut. <br />
<br />
La carte mère rentre en interruption et va alors demander quelle carte a déclenché l'interruption. <br />
<br />
Si c'est la carte clavier qui a déclenché l'interruption alors le carte mère demande le nombre de touche à récupérer, puis récupère une a une les touches. <br />
<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide que l'humain qui tape au clavier. <br />
<br />
<br />
Afin de tester notre communication SPI, nous avons utiliser un Arduino uno qui "remplace" la carte mère. et qui envoi les valeurs 0x00, 0x01 ou 0x05, le carte mère à la lecture de la valeur doit répondre par une autre valeur. <br />
<br />
En revanche, après beaucoup de tests non concluant, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérent avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle.<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
<br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément notre communication SPI, nous avons utiliser le port série de l'arduino uno pour pouvoir voir les données qui sont envoyé depuis la carte clavier, et ainsi s'assurer que quand on appuie sur une touche du clavier, la carte mère récupère bien le code ASCII de cette touche. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
Voici la vidéo montrant le fonctionnement de notre clavier : <br />
<br />
<br />
<big>VIDEO</big> <br />
<br />
=== Programme final ===<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
[[Fichier:Id touche tampon.mov|centré|cadre]]<br />
<br />
<br />
<big>VIDEO</big><br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
==== Différentes vidéos ====</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Sch%C3%A9ma_communication_SPI.png&diff=3074Fichier:Schéma communication SPI.png2024-01-18T15:23:09Z<p>Skaderis : </p>
<hr />
<div>description des étapes de récupération d'une touche</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=3070SE4Binome2023-52024-01-18T15:04:09Z<p>Skaderis : /* Type de carte choisie */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code> <br />
<br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
Pour commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre clavier matricielle est capable de reconnaître une touche en particulier<br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée. <br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
[[Fichier:Premier_test_clavier.mp4|néant|cadre]]'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|cadre|Clavier sans appuie sur SHIFT]]<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|centré|cadre|clavier avec appuie sur SHIFT]]<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. On a donc écrit un programme pour tester le bus SPI. L'idée était simplement d'envoyer une une variable en fonction de ce que l'on recevait. <br />
<br />
Pour utiliser le bus SPI, il est nécessaire d'utiliser une interruption (une ISR) qui permettra, pour rester dans le cahier des charges, d'envoyer des valeurs en fonctions de la valeur que l'on reçoit. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre mèthode de communication : <br />
[[Fichier:Clavier mode spi.png|centré|sans_cadre]]<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide qu'un humain. <br />
<br />
<u>Explication du code :</u><br />
<br />
Puisque c'est un test sur le spi, nous avons seulement envoyé des valeurs aléatoires afin de vérifier si le bus spi marche, mais en gardant la configuration que l'on doit avoir avec le schéma ci-dessus. <br />
<br />
Afin de pouvoir vérifier nos codes correctement, nous avons utiliser un Arduino uno qui "remplace" la carte mère et qui envoi les valeurs 0x00, 0x01 ou 0x05 de la même manière, avec le bus SPI et les bonnes configurations d'initialisation du bus en tant que "maître". <br />
<br />
En revanche, après beaucoup d changement de codes, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérant avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle. <br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
<br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément et de continuer nos tests, le but étant de programmer la gestion de l'affichage des données reçues par le bus SPI sur le port série. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
Voici la vidéo montrant le fonctionnement de notre clavier : <br />
<br />
<br />
<big>VIDEO</big> <br />
<br />
=== Programme final ===<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
[[Fichier:Id touche tampon.mov|centré|cadre]]<br />
<br />
<br />
<big>VIDEO</big><br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
==== Différentes vidéos ====</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2962SE4Binome2023-52024-01-17T18:25:45Z<p>Skaderis : /* Carte FPGA/VHDL */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
Voici cette fois le clignotement des 2 Leds avec l'endormissement des tâches : <br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
<code>void serie_recevoir(void) {</code> <br />
<br />
<code>while(1) {</code> <br />
<br />
<code>loop_until_bit_is_set(UCSR0A, RXC0);</code> <br />
<br />
<code>received_data = UDR0;</code> <br />
<br />
<code>sleepy(1);</code> <br />
<br />
<code>}</code> <br />
<br />
<code>}</code> <br />
<br />
Ici, la variable globale (mémoire partagée) est une variable globale (received_data) en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
<br />
<code>void serie_envoyer(void) {</code><br />
<br />
<code>while(1) {</code><br />
<br />
<code>loop_until_bit_is_set(UCSR0A,UDRE0);</code><br />
<br />
<code>UDR0=received_data;</code><br />
<br />
<code>received_data = '\0';</code><br />
Sans remettre à '\0' comme ici, lorsque l'on appuie sur une touche, celle-ci s'affiche jusqu'à l'appuie d'une autre touche <br />
<br />
<code>sleepy(1);</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code> <br />
<br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données. <br />
[[Fichier:Schéma bloc du driver SPI.png|centré|vignette|442x442px]] <br />
<br />
Voici le code que nous avons écris en VHDL : <br />
<br />
Dans un process : <br />
<br />
<code>case ETAT is</code><br />
<br />
<code>when REPOS => ETAT <= TRANSMISSION;</code><br />
<br />
<code>when TRANSMISSION => if compteur = 8 then</code><br />
<br />
<code>ETAT <= REPOS;</code><br />
<br />
<code>compteur <= 0;</code><br />
<br />
<code>else compteur <= compteur + 1;</code><br />
<br />
<code>end if;</code><br />
<br />
<code>for i in 0 to 6 loop</code><br />
<br />
<code>mosi_in(i) <= mosi_in(i+1);</code><br />
<br />
<code>data_out_s(i) <= data_out_s(i+1);</code><br />
<br />
<code>end loop;</code><br />
<br />
<code>mosi_in(7) <= data_in_s(0);</code><br />
<br />
<code>data_out_s(7) <= mosi_in(0);</code><br />
<br />
<code>end case;</code> <br />
<br />
Hors du process : <br />
<br />
<code>CS1 <= '1' when select_carte = "001" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS2 <= '1' when select_carte = "010" and ETAT <= REPOS else '0';</code> <br />
<br />
<code>CS3 <= '1' when select_carte = "100" and ETAT <= REPOS else '0';</code> <br />
<br />
Nous avons utilisé une machine d'état avec 2 états : un état REPOS qui permet de passer à l'état TRANSMISSION et de mettre à 1 ou à 0 les Chip Select en fonction de la selection d'état que recevra la carte FPGA de la carte mère. Et la fonction transmission qui effectue le registre à décalage. <br />
<br />
Ce code, que vous trouverez dans le git, compile, en revanche nous n'avons pas pu faire de tests dessus malheureusement. <br />
<br />
== Carte électronique numérique ==<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
<u>Amélioration possible :</u> permettre la programmation en USB. Avec cette carte telle qu'elle est faite, pour insérer un programme dans le microcontrôleur il faut passer par la carte Arduino et pour ça, il faut insérer le programme "ArduinoISP" qui se trouver dans les exemples de l'IDE Arduino, sans oublier tous les branchements à refaire. Ce n'est pas vraiment pratique et c'est une perte de temps qu'il est possible d'enlever en mettant un port USB directement sur la carte clavier. <br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
Pour commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre clavier matricielle est capable de reconnaître une touche en particulier<br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée. <br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
[[Fichier:Premier_test_clavier.mp4|néant|cadre]]'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x08 : suppression<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|cadre|Clavier sans appuie sur SHIFT]]<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|centré|cadre|clavier avec appuie sur SHIFT]]<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lues par le clavier vers la carte mère grâce au bus SPI. On a donc écrit un programme pour tester le bus SPI. L'idée était simplement d'envoyer une une variable en fonction de ce que l'on recevait. <br />
<br />
Pour utiliser le bus SPI, il est nécessaire d'utiliser une interruption (une ISR) qui permettra, pour rester dans le cahier des charges, d'envoyer des valeurs en fonctions de la valeur que l'on reçoit. <br />
<br />
<code>ISR(SPI_STC_vect) {</code> <br />
<br />
<code> char data = SPDR;</code> <br />
<br />
<code> _delay_ms(40);</code> <br />
<br />
<code> if(data == 0x00) {</code> <br />
<br />
<code> SPDR = '!';</code> <br />
<br />
<code> } else if (data == 0x05) {</code> <br />
<br />
<code> SPDR = bouton;</code> bouton : touche qui a été appuyée <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre mèthode de communication : <br />
[[Fichier:Clavier mode spi.png|centré|sans_cadre]]<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide qu'un humain. <br />
<br />
<u>Explication du code :</u><br />
<br />
Puisque c'est un test sur le spi, nous avons seulement envoyé des valeurs aléatoires afin de vérifier si le bus spi marche, mais en gardant la configuration que l'on doit avoir avec le schéma ci-dessus. <br />
<br />
Afin de pouvoir vérifier nos codes correctement, nous avons utiliser un Arduino uno qui "remplace" la carte mère et qui envoi les valeurs 0x00, 0x01 ou 0x05 de la même manière, avec le bus SPI et les bonnes configurations d'initialisation du bus en tant que "maître". <br />
<br />
En revanche, après beaucoup d changement de codes, la communication ne fonctionnait pas. Nous avons alors regardé à l’oscilloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérant avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasées, ce qui fait que la valeur récupérée par le maitre est toujours nulle. <br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. La seule carte avec laquelle nos programmes fonctionnent, c'est avec celle du groupe 9. Les shields des binômes 4,5 et 6 ont ce problème. <br />
<br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément et de continuer nos tests, le but étant de programmer la gestion de l'affichage des données reçues par le bus SPI sur le port série. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1) {</code> <br />
<br />
<code> spi_activer();</code> <br />
<br />
<code> _delay_ms(20);</code> <br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code> <br />
<br />
<code> spi_desactiver();</code> <br />
<br />
<code> _delay_ms(100);</code> <br />
<br />
<code>}</code> <br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
Voici la vidéo montrant le fonctionnement de notre clavier : <br />
<br />
<br />
<big>VIDEO</big> <br />
<br />
=== Programme final ===<br />
Finalement, l'idée est de stocker les touches appuyées dans un tableau, pour pouvoir les envoyer à la carte mère lorsqu'elle le demande. Avant la demande de touche, la carte mère envoi la donnée 0x00 pour que l'on réponde que la carte est un clavier avec le caractère '!'. Nous avons décidé d'utilisé cette réponse seulement pour que l'on puisse l'afficher sur le port série (0x05 étant un caractère non imprimable). <br />
<br />
Voici les fonctions qui permettent d'ajouter et de supprimer les touches du tampon : <br />
<br />
<code>void remplir_tampon() {</code><br />
<br />
<code>tampon[cpt_tampon] = bouton;</code><br />
<br />
<code>cpt_tampon++;</code> <br />
<br />
<code>}</code> <br />
<br />
<code>void vider_tampon() {</code><br />
<br />
<code>for (int i=0; i < cpt_tampon; i++) {</code><br />
<br />
<code>if (i == cpt_tampon - 1 ) {</code><br />
<br />
<code>tampon[i] = '\0';</code><br />
<br />
<code>} else {</code><br />
<br />
<code>tampon[i] = tampon[i+1];</code><br />
<br />
<code>}</code><br />
<br />
<code>}</code><br />
<br />
<code>cpt_tampon--;</code> <br />
<br />
<code>}</code> <br />
<br />
L'idée est de vider le tampon à chaque fois que l'on envoi le tableau à la case 0 : <br />
<br />
<code>if(data == 0x05) {</code><br />
<br />
<code>SPDR = tampon[0];</code><br />
<br />
<code>vider_tampon();</code><br />
<br />
<code>if(cpt_tampon == 0) {</code><br />
<br />
<code>PORTC &= ~(1 << PC4);</code><br />
<br />
<code>}</code> <br />
<br />
En conclusion, le programme de la carte mère envoi la demande d'identification (0x00) ainsi que la demande de touche. Et le programme du clavier envoi le caractère '!', et par la suite la touche du tampon. <br />
<br />
<br />
<big>VIDEO</big><br />
<br />
'''Remarque :''' ce code n'est pas parfait puisqu'il écrit 1 fois de trop le caractère. Ex : si on appuie sur 'A', on lira sur le port série 'A', en revanche si on appuie juste après sur 'B', on lira 'A' puis 'B'. Nous n'avons malheureusement pas pu décoder cette erreur. <br />
<br />
==== Points importants à savoir ====<br />
il faut débrancher et rebrancher le câble du bus SPI pour que la communication fonctionne. Aussi, si le programme du maître ne s'injecte pas dans l'Arduino, il faut insérer d'abord un programme d'exemple comme ArduinoISP. <br />
<br />
<br />
Nous avons mis à part des programmes fonctionnels dans les répertoires nommés "Codes_OK". Tout est expliqué dans des README qui se trouvent (presque) dans chaque répertoire. Un README qui se trouve dans le répertoire clavier/Code explique ce que les combinaisons de codes du maître et de l'esclave font. Des vidéos se trouvent également dans le répertoire Videos, qui montrent la fonctionnalité de chaque codes. Il y a d'ailleurs <u>plus (+) de vidéos</u> sur le git. <br />
<br />
==== Différentes vidéos ====</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Sch%C3%A9ma_bloc_du_driver_SPI.png&diff=2961Fichier:Schéma bloc du driver SPI.png2024-01-17T18:25:04Z<p>Skaderis : </p>
<hr />
<div>fonctionnement global du driver spi série</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Sch%C3%A9ma_bloc.png&diff=2960Fichier:Schéma bloc.png2024-01-17T18:16:45Z<p>Skaderis : </p>
<hr />
<div>Schéma bloc du code VHDL</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Sch%C3%A9ma_bloc_driver_spi.png&diff=2959Fichier:Schéma bloc driver spi.png2024-01-17T18:08:43Z<p>Skaderis : </p>
<hr />
<div>schéma qui décris le code vhdl réalisé</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2777SE4Binome2023-52024-01-16T13:16:07Z<p>Skaderis : /* Carte FPGA/VHDL */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
[[Fichier:Ordo lecture serie.png|sans_cadre]]Ici, la mémoire partagée est une variable globale en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
[[Fichier:Ordo_lecture_ecriture.png|gauche|sans_cadre]] <br />
Cette fonction permettra d'écrire directement sur le port série grâce au caractère que l'on aura lu précédemment. <br />
<br />
En revanche, cette fonction n'est pas utilisée pour de l'ordonnancement mais elle est utilisée par la fonction suivante qui elle est utilisée pour de l'ordonnancement (et donc fait parti des taches) <br />
<br />
[[Fichier:Ordo_lect_ecr.png|sans_cadre]]<br />
<br />
'''Remarque :''' Après réflexion nous aurions pu éviter de mettre en paramètre le caractère lu puisque la variable globale est utile pour ça. <br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous. C'est le principe du registre à décalage.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]Le contrôleur SPI doit jouer le rôle du maître et va contrôler les pins du bus SPI pour échanger des données : <br />
<br />
== Carte électronique numérique ==<br />
<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
<u>Amélioration possible :</u> permettre la programmation en USB. Avec cette carte telle qu'elle est faite, pour insérer un programme dans le microcontrôleur il faut passer par la carte Arduino et pour ça, il faut insérer le programme "ArduinoISP" qui se trouver dans les exemples de l'IDE Arduino, sans oublier tous les branchements à refaire. Ce n'est pas vraiment pratique et c'est une perte de temps qu'il est possible d'enlever en mettant un port USB directement sur la carte clavier. <br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
Pour commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre clavier matricielle est capable de reconnaître une touche en particulier<br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée. <br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
[[Fichier:Premier_test_clavier.mp4|néant|cadre]]'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* '''<big>0x08 : suppression</big>'''<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|cadre|Clavier sans appuyer sur SHIFT]]<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|centré|cadre|clavier avec appuie sur SHIFT]]<br />
<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lu par le clavier vers la carte mère grâce au bus SPI. On a donc écrit un programme pour tester le bus SPI. L'idée était simplement d'envoyer une une variable en fonction de ce que l'on recevait. <br />
<br />
Pour utiliser le bus SPI, il est nécessaire d'utiliser une interruption (une ISR) qui permettra, pour rester dans le cahier des charges, d'envoyer des valeurs en fonctions de la valeur que l'on reçoit. <br />
<br />
<code>ISR(SPI_STC_vect) {</code><br />
<br />
<code> char data = SPDR;</code><br />
<br />
<code> _delay_ms(40);</code><br />
<br />
<code> if(data == 0x00) {</code><br />
<br />
<code> SPDR = '!';</code><br />
<br />
<code> } else if (data == 0x01) {</code><br />
<br />
<code> SPDR = bouton;</code> ici la valeur de bouton est initialisée à 1. <br />
<br />
<code> } else if (data == 0x05) SPDR = 'C';</code> il n'y a pas encore le traitement de la touche sur laquelle on a appuyé. <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre mèthode de communication : <br />
[[Fichier:Clavier mode spi.png|centré|sans_cadre]]<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide qu'un humain. <br />
<br />
<u>Explication du code :</u><br />
<br />
Puisque c'est un test sur le spi, nous avons seulement envoyé des valeurs aléatoires afin de vérifier si le bus spi marche, mais en gardant la configuration que l'on doit avoir avec le schéma ci-dessus. <br />
<br />
<br />
<br />
Afin de pouvoir vérifier nos codes correctement, nous avons utiliser un arduino uno qui "remplace" la carte mère et qui envoit les valeurs 0x00, 0x01 ou 0x05 de la même manière, avec le bus SPI et les bonnes configurations d'initialisation du bus en tant que "maître". <br />
<br />
<br />
Nous avons regardé à l'osciloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérant avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasé, ce qui fait que la valeur récuperé par le maitre est toujours zéro<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. <br />
<br />
Les shields des binomes 4,5 et 6 ont ce problème. <br />
<br />
Les shields des binomes 8 et 9 fonctionnent <br />
<br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément et de continuer nos tests, le but étant de programmer la gestion de l'affichage des données reçues par le bus SPI sur le port série. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1){</code><br />
<br />
<code> spi_activer();</code><br />
<br />
<code> _delay_ms(20);</code><br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code><br />
<br />
<code> spi_desactiver();</code><br />
<br />
<code> _delay_ms(100);</code><br />
<br />
<code>}</code><br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
Voici la vidéo montrant le fonctionnement de notre clavier : <br />
<br />
<br />
<big>VIDEO</big> <br />
<br />
=== Programme final ===</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2685SE4Binome2023-52024-01-15T11:58:49Z<p>Skaderis : /* Deuxième test : la lecture d'un bouton */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
[[Fichier:Ordo lecture serie.png|sans_cadre]]Ici, la mémoire partagée est une variable globale en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
[[Fichier:Ordo_lecture_ecriture.png|gauche|sans_cadre]] <br />
Cette fonction permettra d'écrire directement sur le port série grâce au caractère que l'on aura lu précédemment. <br />
<br />
En revanche, cette fonction n'est pas utilisée pour de l'ordonnancement mais elle est utilisée par la fonction suivante qui elle est utilisée pour de l'ordonnancement (et donc fait parti des taches) <br />
<br />
[[Fichier:Ordo_lect_ecr.png|sans_cadre]]<br />
<br />
'''Remarque :''' Après réflexion nous aurions pu éviter de mettre en paramètre le caractère lu puisque la variable globale est utile pour ça. <br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]<br />
<br />
== Carte électronique numérique ==<br />
<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
<u>Amélioration possible :</u> permettre la programmation en USB. Avec cette carte telle qu'elle est faite, pour insérer un programme dans le microcontrôleur il faut passer par la carte Arduino et pour ça, il faut insérer le programme "ArduinoISP" qui se trouver dans les exemples de l'IDE Arduino, sans oublier tous les branchements à refaire. Ce n'est pas vraiment pratique et c'est une perte de temps qu'il est possible d'enlever en mettant un port USB directement sur la carte clavier. <br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
Pour commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que notre clavier matricielle est capable de reconnaître une touche en particulier<br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée. <br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
[[Fichier:Premier_test_clavier.mp4|néant|cadre]]'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* '''<big>0x08 : suppression</big>'''<br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|cadre|Clavier sans appuyer sur SHIFT]]<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|centré|cadre|clavier avec appuie sur SHIFT]]<br />
<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches lu par le clavier vers la carte mère grâce au bus SPI. On a donc écrit un programme pour tester le bus SPI. L'idée était simplement d'envoyer une une variable en fonction de ce que l'on recevait. <br />
<br />
Pour utiliser le bus SPI, il est nécessaire d'utiliser une interruption (une ISR) qui permettra, pour rester dans le cahier des charges, d'envoyer des valeurs en fonctions de la valeur que l'on reçoit. <br />
<br />
<code>ISR(SPI_STC_vect) {</code><br />
<br />
<code> char data = SPDR;</code><br />
<br />
<code> _delay_ms(40);</code><br />
<br />
<code> if(data == 0x00) {</code><br />
<br />
<code> SPDR = '!';</code><br />
<br />
<code> } else if (data == 0x01) {</code><br />
<br />
<code> SPDR = bouton;</code> ici la valeur de bouton est initialisée à 1. <br />
<br />
<code> } else if (data == 0x05) SPDR = 'C';</code> il n'y a pas encore le traitement de la touche sur laquelle on a appuyé. <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre mèthode de communication : <br />
[[Fichier:Clavier mode spi.png|centré|sans_cadre]]<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide qu'un humain. <br />
<br />
<u>Explication du code :</u><br />
<br />
Puisque c'est un test sur le spi, nous avons seulement envoyé des valeurs aléatoires afin de vérifier si le bus spi marche, mais en gardant la configuration que l'on doit avoir avec le schéma ci-dessus. <br />
<br />
<br />
<br />
Afin de pouvoir vérifier nos codes correctement, nous avons utiliser un arduino uno qui "remplace" la carte mère et qui envoit les valeurs 0x00, 0x01 ou 0x05 de la même manière, avec le bus SPI et les bonnes configurations d'initialisation du bus en tant que "maître". <br />
<br />
<br />
Nous avons regardé à l'osciloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérant avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasé, ce qui fait que la valeur récuperé par le maitre est toujours zéro<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. <br />
<br />
Les shields des binomes 4,5 et 6 ont ce problème. <br />
<br />
Les shields des binomes 8 et 9 fonctionnent <br />
<br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément et de continuer nos tests, le but étant de programmer la gestion de l'affichage des données reçues par le bus SPI sur le port série. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1){</code><br />
<br />
<code> spi_activer();</code><br />
<br />
<code> _delay_ms(20);</code><br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code><br />
<br />
<code> spi_desactiver();</code><br />
<br />
<code> _delay_ms(100);</code><br />
<br />
<code>}</code><br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
Voici la vidéo montrant le fonctionnement de notre clavier : <br />
<br />
<br />
<big>VIDEO</big> <br />
<br />
=== Programme final ===</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2684SE4Binome2023-52024-01-15T10:38:02Z<p>Skaderis : /* Troisième test : lecture de tous les boutons + shift */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
[[Fichier:Ordo lecture serie.png|sans_cadre]]Ici, la mémoire partagée est une variable globale en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
[[Fichier:Ordo_lecture_ecriture.png|gauche|sans_cadre]] <br />
Cette fonction permettra d'écrire directement sur le port série grâce au caractère que l'on aura lu précédemment. <br />
<br />
En revanche, cette fonction n'est pas utilisée pour de l'ordonnancement mais elle est utilisée par la fonction suivante qui elle est utilisée pour de l'ordonnancement (et donc fait parti des taches) <br />
<br />
[[Fichier:Ordo_lect_ecr.png|sans_cadre]]<br />
<br />
'''Remarque :''' Après réflexion nous aurions pu éviter de mettre en paramètre le caractère lu puisque la variable globale est utile pour ça. <br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]<br />
<br />
== Carte électronique numérique ==<br />
<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
<u>Amélioration possible :</u> permettre la programmation en USB. Avec cette carte telle qu'elle est faite, pour insérer un programme dans le microcontrôleur il faut passer par la carte Arduino et pour ça, il faut insérer le programme "ArduinoISP" qui se trouver dans les exemples de l'IDE Arduino, sans oublier tous les branchements à refaire. Ce n'est pas vraiment pratique et c'est une perte de temps qu'il est possible d'enlever en mettant un port USB directement sur la carte clavier. <br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
Pour commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que nous avions bien compris la méthode du clavier matriciel<br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée. <br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
[[Fichier:Premier_test_clavier.mp4|néant|cadre]]'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x7F : suppression <br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|cadre|Clavier sans appuyer sur SHIFT]]<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|centré|cadre|clavier avec appuie sur SHIFT]]<br />
<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches à la carte mère grâce au bus SPI. On a donc écrit un programme pour tester le bus SPI. L'idée était simplement d'envoyer une une variable en fonction de ce que l'on recevait. <br />
<br />
Pour utiliser le bus SPI, il est nécessaire d'utiliser une interruption (une ISR) qui permettra, pour rester dans le cahier des charges, d'envoyer des valeurs en fonctions de la valeur que l'on reçoit. <br />
<br />
<code>ISR(SPI_STC_vect) {</code><br />
<br />
<code> char data = SPDR;</code><br />
<br />
<code> _delay_ms(40);</code><br />
<br />
<code> if(data == 0x00) {</code><br />
<br />
<code> SPDR = '!';</code><br />
<br />
<code> } else if (data == 0x01) {</code><br />
<br />
<code> SPDR = bouton;</code> ici la valeur de bouton est initialisée à 1. <br />
<br />
<code> } else if (data == 0x05) SPDR = 'C';</code> il n'y a pas encore le traitement de la touche sur laquelle on a appuyé. <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre mèthode de communication : <br />
[[Fichier:Clavier mode spi.png|centré|sans_cadre]]<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide qu'un humain. <br />
<br />
<u>Explication du code :</u><br />
<br />
Puisque c'est un test sur le spi, nous avons seulement envoyé des valeurs aléatoires afin de vérifier si le bus spi marche, mais en gardant la configuration que l'on doit avoir avec le schéma ci-dessus. <br />
<br />
<br />
<br />
Afin de pouvoir vérifier nos codes correctement, nous avons utiliser un arduino uno qui "remplace" la carte mère et qui envoit les valeurs 0x00, 0x01 ou 0x05 de la même manière, avec le bus SPI et les bonnes configurations d'initialisation du bus en tant que "maître". <br />
<br />
<br />
Nous avons regardé à l'osciloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérant avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasé, ce qui fait que la valeur récuperé par le maitre est toujours zéro<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. <br />
<br />
Les shields des binomes 4,5 et 6 ont ce problème. <br />
<br />
Les shields des binomes 8 et 9 fonctionnent <br />
<br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément et de continuer nos tests, le but étant de programmer la gestion de l'affichage des données reçues par le bus SPI sur le port série. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1){</code><br />
<br />
<code> spi_activer();</code><br />
<br />
<code> _delay_ms(20);</code><br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code><br />
<br />
<code> spi_desactiver();</code><br />
<br />
<code> _delay_ms(100);</code><br />
<br />
<code>}</code><br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
Voici la vidéo montrant le fonctionnement de notre clavier : <br />
<br />
<br />
<big>VIDEO</big> <br />
<br />
=== Programme final ===</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2683SE4Binome2023-52024-01-15T10:37:44Z<p>Skaderis : /* Troisième test : lecture de tous les boutons + shift */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
[[Fichier:Ordo lecture serie.png|sans_cadre]]Ici, la mémoire partagée est une variable globale en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
[[Fichier:Ordo_lecture_ecriture.png|gauche|sans_cadre]] <br />
Cette fonction permettra d'écrire directement sur le port série grâce au caractère que l'on aura lu précédemment. <br />
<br />
En revanche, cette fonction n'est pas utilisée pour de l'ordonnancement mais elle est utilisée par la fonction suivante qui elle est utilisée pour de l'ordonnancement (et donc fait parti des taches) <br />
<br />
[[Fichier:Ordo_lect_ecr.png|sans_cadre]]<br />
<br />
'''Remarque :''' Après réflexion nous aurions pu éviter de mettre en paramètre le caractère lu puisque la variable globale est utile pour ça. <br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]<br />
<br />
== Carte électronique numérique ==<br />
<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
<u>Amélioration possible :</u> permettre la programmation en USB. Avec cette carte telle qu'elle est faite, pour insérer un programme dans le microcontrôleur il faut passer par la carte Arduino et pour ça, il faut insérer le programme "ArduinoISP" qui se trouver dans les exemples de l'IDE Arduino, sans oublier tous les branchements à refaire. Ce n'est pas vraiment pratique et c'est une perte de temps qu'il est possible d'enlever en mettant un port USB directement sur la carte clavier. <br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
Pour commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que nous avions bien compris la méthode du clavier matriciel<br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée. <br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
[[Fichier:Premier_test_clavier.mp4|néant|cadre]]'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x7F : suppression <br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|cadre|Clavier sans appuyer sur SHIFT]]<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|centré|cadre|clavier avec appuie sur SHIFT]]<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches à la carte mère grâce au bus SPI. On a donc écrit un programme pour tester le bus SPI. L'idée était simplement d'envoyer une une variable en fonction de ce que l'on recevait. <br />
<br />
Pour utiliser le bus SPI, il est nécessaire d'utiliser une interruption (une ISR) qui permettra, pour rester dans le cahier des charges, d'envoyer des valeurs en fonctions de la valeur que l'on reçoit. <br />
<br />
<code>ISR(SPI_STC_vect) {</code><br />
<br />
<code> char data = SPDR;</code><br />
<br />
<code> _delay_ms(40);</code><br />
<br />
<code> if(data == 0x00) {</code><br />
<br />
<code> SPDR = '!';</code><br />
<br />
<code> } else if (data == 0x01) {</code><br />
<br />
<code> SPDR = bouton;</code> ici la valeur de bouton est initialisée à 1. <br />
<br />
<code> } else if (data == 0x05) SPDR = 'C';</code> il n'y a pas encore le traitement de la touche sur laquelle on a appuyé. <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre mèthode de communication : <br />
[[Fichier:Clavier mode spi.png|centré|sans_cadre]]<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide qu'un humain. <br />
<br />
<u>Explication du code :</u><br />
<br />
Puisque c'est un test sur le spi, nous avons seulement envoyé des valeurs aléatoires afin de vérifier si le bus spi marche, mais en gardant la configuration que l'on doit avoir avec le schéma ci-dessus. <br />
<br />
<br />
<br />
Afin de pouvoir vérifier nos codes correctement, nous avons utiliser un arduino uno qui "remplace" la carte mère et qui envoit les valeurs 0x00, 0x01 ou 0x05 de la même manière, avec le bus SPI et les bonnes configurations d'initialisation du bus en tant que "maître". <br />
<br />
<br />
Nous avons regardé à l'osciloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérant avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasé, ce qui fait que la valeur récuperé par le maitre est toujours zéro<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. <br />
<br />
Les shields des binomes 4,5 et 6 ont ce problème. <br />
<br />
Les shields des binomes 8 et 9 fonctionnent <br />
<br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément et de continuer nos tests, le but étant de programmer la gestion de l'affichage des données reçues par le bus SPI sur le port série. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1){</code><br />
<br />
<code> spi_activer();</code><br />
<br />
<code> _delay_ms(20);</code><br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code><br />
<br />
<code> spi_desactiver();</code><br />
<br />
<code> _delay_ms(100);</code><br />
<br />
<code>}</code><br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
Voici la vidéo montrant le fonctionnement de notre clavier : <br />
<br />
<br />
<big>VIDEO</big> <br />
<br />
=== Programme final ===</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2682SE4Binome2023-52024-01-15T10:37:22Z<p>Skaderis : /* Deuxième test : la lecture d'un bouton */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Lors de la première séance de Pico, nous avons soudé quelques cartes telles que le Shield, la carte de leds et la carte 7 segments : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]][[Fichier:CartePin.png|sans_cadre|209x209px]][[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino qui nous servirons pour la communication du bus SPI : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation Ordonnancement ===<br />
<br />
==== Clignotement de 2 Leds ====<br />
<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, l'objectif est donc d'endormir les tâches. <br />
<br />
==== Lecture sur port série en mémoire partagée ====<br />
Par la suite, nous voulons ordonnancer une tâche qui permet de stocker dans une mémoire partagée la valeur reçue sur le port série. <br />
<br />
Voici le code que nous avons utilisé : <br />
<br />
[[Fichier:Ordo lecture serie.png|sans_cadre]]Ici, la mémoire partagée est une variable globale en unsigned char. <br />
<br />
Pour lire sur le port série, on utilisera la commande <code>minicom -D /dev/ttyUSB0 -b 9600</code> <br />
<br />
==== Lecture/écriture sur port série ====<br />
Afin de vérifier le code que nous avons écris dans la partie d'avant, nous écrirons sur le port série ce que nous avons lu. En d'autres termes, nous écrirons sur le port série ce que nous avons écris sur le clavier. <br />
[[Fichier:Ordo_lecture_ecriture.png|gauche|sans_cadre]] <br />
Cette fonction permettra d'écrire directement sur le port série grâce au caractère que l'on aura lu précédemment. <br />
<br />
En revanche, cette fonction n'est pas utilisée pour de l'ordonnancement mais elle est utilisée par la fonction suivante qui elle est utilisée pour de l'ordonnancement (et donc fait parti des taches) <br />
<br />
[[Fichier:Ordo_lect_ecr.png|sans_cadre]]<br />
<br />
'''Remarque :''' Après réflexion nous aurions pu éviter de mettre en paramètre le caractère lu puisque la variable globale est utile pour ça. <br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclave précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'esclave, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]<br />
<br />
== Carte électronique numérique ==<br />
<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
L'objectif de ce projet pour la carte clavier est de lire les boutons qui sont enfoncés afin de les envoyer à la carte mère via le bus SPI. <br />
<br />
=== Partie électronique ===<br />
Voici le schéma électronique fini de notre carte : [[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]]Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches qui sont : la flèche de gauche, la flèche de droite, l'espace, un retour chariot, le suppression et enfin un shift qui nous permettra de switcher avec les 10 chiffres (de 0 à 9), <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
<u>Fonctionnement matrice de touches :</u><br />
<br />
Le but ici est de pouvoir lire la touche sur laquelle nous avons appuyé pour l'envoyer à la carte mère. Ici, l'idée est d'utiliser le fonctionnement de la matrice de touche qui est le suivant : <br />
<br />
Premièrement, il faut se décider duquel entre les lignes et les colonnes seront en entrée et l'autre en sortie. Ici se sont les lignes qui sont en sortie et les colonnes en entrée. <br />
<br />
L'idée est simple : alterner entre les lignes pour écrire un 0L sur 1 ligne et sur les autres un 1L. On parcourt ensuite toutes les colonnes (de la ligne à 0L). Si on lit un 0L sur une colonne, alors il suffit d'associer la ligne qui est à 0L avec celle de la colonne et on connait la touche qui a été appuyée. <br />
<br />
Les résistances de pull up qui se trouvent au niveau des lignes serviront à avoir un 1L par défaut. <br />
<br />
<br />
Voici le routage de la carte : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal.<br />
<br />
Pour faire ce routage, nous avons dû créer le footprint des boutons, alors la prise des mesures sur le boutons était nécessaire. Aussi, nous avons décidé d'utiliser un ATmega328p avec des pins traversants pour une question de facilité au niveau de la soudure mais également pour éviter tout court-circuit et donc une perte de temps. <br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]]<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réel clavier avec toutes les touches (ici 32) : <br />
<br />
[[Fichier:Carte_soude.jpg|sans_cadre|266x266px]]<br />
<br />
<u>Amélioration possible :</u> permettre la programmation en USB. Avec cette carte telle qu'elle est faite, pour insérer un programme dans le microcontrôleur il faut passer par la carte Arduino et pour ça, il faut insérer le programme "ArduinoISP" qui se trouver dans les exemples de l'IDE Arduino, sans oublier tous les branchements à refaire. Ce n'est pas vraiment pratique et c'est une perte de temps qu'il est possible d'enlever en mettant un port USB directement sur la carte clavier. <br />
<br />
=== Partie programmation ===<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on téléverse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le connecteur HE10. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|400x400px|sans_cadre]]<br />
Pour flasher notre carte clavier, 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des tests rapides en utilisant, par exemple, l'exemple "Blink".<br />
* Créer un Makefile qui permet de téléverser notre code C vers la carte fille en passant par l'arduino uno :<br />
[[Fichier:Makefil.png|sans_cadre|450x450px]] <br />
<br />
==== Programme de tests sur la carte ====<br />
Nous sommes ensuite passés au différents tests de la carte pour tester chaque fonctionnalités. <br />
<br />
===== Premier test : la carte est-elle programmable ? =====<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le "Blink" disponible dans les exemples de l'IDE arduino. <br />
<br />
Cependant, en essayant de programmer la carte, aucune LEDs ne clignotait. Comme le code ne venait pas de nous et qe c'est un code simple, le problème ne pouvait venir que du côté du hardware. Nous avons donc tester notre carte au multimètre et il y avait effectivement un court-circuit au niveau du crystal qui empêchait forcement son fonctionnement. L'erreur vient de notre schématique puisque nous avons tourné à 90° le composant, ce qui créé effectivement un court-circuit. Pour remédier à notre problème, nous avons dé-souder le crystal et l'avons décalé sur la carte. <br />
<br />
Une fois le crystal re-soudé dans le bon sens, nous avons pu flasher la carte clavier avec le programme "Blink"<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<u>Conclusion :</u> La LED clignote, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP.<br />
<br />
===== Deuxième test : la lecture d'un bouton =====<br />
Pour commencer les tests, nous cherchons à allumer une LED quand on appuie sur un bouton en particulier. Pour cela, nous avons mis à 0L la ligne sur PC3 et lu la colonne sur PD0 : <br />
<br />
[[Fichier:Test_clavier.png|sans_cadre|600x600px]]<br />
<br />
Ce test nous a permit de vérifier 2 choses : <br />
<br />
* que nous avions bien compris la méthode du clavier matriciel<br />
* que nous arrivions bien à utiliser les Leds de notre carte. Ainsi nous avons nos "calculs" avec les décalages et les opérations logiques utiles pour mettre à 0L ou lire sur le port une entrée. <br />
<br />
Par la suite nous avons gardé l'idée d'allumer une Led lorsqu'un bouton est enfoncé. <br />
<br />
[[Fichier:Premier_test_clavier.mp4|néant|cadre]]'''Problème rencontré :''' Au début nous n'arrivions par à lire le bouton bien que notre code soit simple. Nous avons donc vérifié au multimètre si nos boutons étaient bien soudés. Au multimètre, les 4 broches de chaque bouton étaient reliés (donc en court-circuit), ce n'est absolument pas normal. Effectivement, lorsque nous avions créé les footprints des boutons nous n'avons pas mis les broches au bon endroit. Dans les boutons il y a déjà des broches reliées et dans nos footprint nous n'avons pas mis les bons chiffres des broches correctement : ce qui nous a créé un court-circuit. Pour contrer ce problème, nous avons tourné à 90° chaque bouton. C n'était pas simple car il a fallut redresser les pins pour qu'ils rentrent bien dans les trous de la carte. Finalement les boutons fonctionnent correctement et les boutons restent assez droits. <br />
<br />
===== Troisième test : lecture de tous les boutons + shift =====<br />
Pour commencer, on definit notre matrice de touches grâce à un tableau à 2 dimensions, ça nous permettra de récupérer directement les bonnes touches. <br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas, alors les touches seront dans l'ordre alphabétique. Dans le code, les lettres ne sont pas dans l'ordre simplement parce que lors du routage nous n'avons pas laissé les boutons comme dans la schématique par simplicité de routage : <br />
[[Fichier:Matrice touches.png|gauche|sans_cadre]]<br />
<u>traduction des valeurs hexadécimales :</u> <br />
<br />
* 0x0E : le shift <br />
* 0x7F : suppression <br />
* 0x1C : flèche gauche <br />
* 0x1D : flèche droite <br />
<br />
Ce sont simplement les codes en ASCII. <br />
[[Fichier:Lecture touches.png|gauche|sans_cadre|400x400px]]<br />
<br />
<br />
<br />
<br />
<br />
Cette fonction nous permet d'effectuer la lecture d'une touche avec la méthode du clavier matriciel que nous avons expliqué plus haut. <br />
<br />
Ainsi, pour chaque ligne à 0L on lira sur chaque colonne et on vérifie si elle est égale à 0L. Si oui, on retourne directement la valeur de la touche en retournant notre matrice de touches avec les indices de la ligne et de la colonne en cours. <br />
<br />
Il y a une condition supplémentaire : si la touche appuyée est le shift (0x0E). Dans ce cas, on bascule on recommence la même méthode, mais cette fois on retournera la valeur appuyée mais grâce à la deuxième matrice cette fois puisqu'elle contient les chiffres de 0 à 9. <br />
<br />
Ici, l'utilisateur devra appuyer sur le bouton pour les chiffres en même temps que le bouton du shift. <br />
<br />
<br />
<br />
<br />
<br />
<br />
Finalement, notre clavier ce présent comme ceci : <br />
[[Fichier:Tableau du clavier.png|gauche|cadre|Clavier sans appuyer sur SHIFT]]<br />
[[Fichier:Schéma clavier avec appuie sur SHIFT.png|centré|cadre|clavier avec appuie sur SHIFT]]<br />
<br />
<br />
===== Quatrième test : le bus SPI =====<br />
<br />
L'objectif de cette partie est d'envoyer les touches à la carte mère grâce au bus SPI. On a donc écrit un programme pour tester le bus SPI. L'idée était simplement d'envoyer une une variable en fonction de ce que l'on recevait. <br />
<br />
Pour utiliser le bus SPI, il est nécessaire d'utiliser une interruption (une ISR) qui permettra, pour rester dans le cahier des charges, d'envoyer des valeurs en fonctions de la valeur que l'on reçoit. <br />
<br />
<code>ISR(SPI_STC_vect) {</code><br />
<br />
<code> char data = SPDR;</code><br />
<br />
<code> _delay_ms(40);</code><br />
<br />
<code> if(data == 0x00) {</code><br />
<br />
<code> SPDR = '!';</code><br />
<br />
<code> } else if (data == 0x01) {</code><br />
<br />
<code> SPDR = bouton;</code> ici la valeur de bouton est initialisée à 1. <br />
<br />
<code> } else if (data == 0x05) SPDR = 'C';</code> il n'y a pas encore le traitement de la touche sur laquelle on a appuyé. <br />
<br />
<code>}</code><br />
<br />
<br />
<u>Explication de la communication en bus SPI :</u><br />
<br />
Dans cette partie, l'idée est de communiquer avec la carte mère. Pour cela, voici un schéma explicatif de notre mèthode de communication : <br />
[[Fichier:Clavier mode spi.png|centré|sans_cadre]]<br />
'''Remarque :''' la taille du tampon sera, le plus souvent, égale à 1 puisque le microcontrôleur est plus rapide qu'un humain. <br />
<br />
<u>Explication du code :</u><br />
<br />
Puisque c'est un test sur le spi, nous avons seulement envoyé des valeurs aléatoires afin de vérifier si le bus spi marche, mais en gardant la configuration que l'on doit avoir avec le schéma ci-dessus. <br />
<br />
<br />
<br />
Afin de pouvoir vérifier nos codes correctement, nous avons utiliser un arduino uno qui "remplace" la carte mère et qui envoit les valeurs 0x00, 0x01 ou 0x05 de la même manière, avec le bus SPI et les bonnes configurations d'initialisation du bus en tant que "maître". <br />
<br />
<br />
Nous avons regardé à l'osciloscope l'allure de nos signaux MISO et MOSI : <br />
<br />
* Le MOSI était cohérant avec les données envoyées<br />
* Le MISO en revanche a des valeurs de tensions écrasé, ce qui fait que la valeur récuperé par le maitre est toujours zéro<br />
<br />
[[Fichier:MOSI.png|gauche|vignette|MOSI]]<br />
[[Fichier:MISO.png|centré|vignette|MISO|290x290px]]<br />
<br />
<u>Conclusion :</u> Après de nombreux essais sur différents shield, le bus SPI de certaines cartes ne fonctionnent pas, et d'autres fonctionnent, et ce même avec un code identiques. C'est assez troublant puisque même avec la dernière carte modifiée et soudée par M. Redon, le bus SPI ne fonctionne pas avec notre code. <br />
<br />
Les shields des binomes 4,5 et 6 ont ce problème. <br />
<br />
Les shields des binomes 8 et 9 fonctionnent <br />
<br />
===== Cinquième test : affichage sur le port série =====<br />
<br />
Afin de vérifier plus précisément et de continuer nos tests, le but étant de programmer la gestion de l'affichage des données reçues par le bus SPI sur le port série. <br />
<br />
Pour ce faire, nous utilisons la même fonction <code>serie_envoyer()</code> que dans l'ordonnanceur. <br />
<br />
<code>while(1){</code><br />
<br />
<code> spi_activer();</code><br />
<br />
<code> _delay_ms(20);</code><br />
<br />
<code> data_recue = spi_envoi(0x05);</code><br />
<br />
<code> serie_envoyer(data_recue);</code><br />
<br />
<code> spi_desactiver();</code><br />
<br />
<code> _delay_ms(100);</code><br />
<br />
<code>}</code><br />
<br />
Le but étant, ici, d'envoyer directement la demande de touche et de l'afficher directement sur le port série grâce au <code>minicom</code>. <br />
<br />
Voici la vidéo montrant le fonctionnement de notre clavier : <br />
<br />
<br />
<big>VIDEO</big> <br />
<br />
=== Programme final ===</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Sch%C3%A9ma_clavier_avec_appuie_sur_SHIFT.png&diff=2681Fichier:Schéma clavier avec appuie sur SHIFT.png2024-01-15T10:11:18Z<p>Skaderis : </p>
<hr />
<div>"map" du clavier quand SHIFT est appuyé</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Tableau_du_clavier.png&diff=2680Fichier:Tableau du clavier.png2024-01-15T10:06:17Z<p>Skaderis : </p>
<hr />
<div>Ce tableau est une "map" de notre clavier</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2648SE4Binome2023-52024-01-10T11:45:30Z<p>Skaderis : /* Type de carte choisie */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Nous avons commencé par souder le redresseur de niveau, le lecteur de carte puis les résistances et les Leds : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre|205x205px]]<br />
<br />
Également, nous avons partiellement soudé la carte de Leds suivante : <br />
<br />
[[Fichier:CartePin.png|sans_cadre|209x209px]]<br />
<br />
Puis, nous avons soudé entièrement la carte 7 segments comme suit : <br />
<br />
[[Fichier:7_segments.png|sans_cadre|213x213px]]<br />
<br />
Et pour finir, la carte Shield est entièrement soudée : <br />
<br />
[[Fichier:Shield.png|sans_cadre|203x203px]][[Fichier:Back.png|sans_cadre|200x200px]]<br />
<br />
<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino : <br />
<br />
[[Fichier:Câbles.png|sans_cadre|169x169px]]<br />
=== Programmation ===<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente : [[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]'''Remarque :''' Les temps ne sont pas réels, c'est pour ça que l'objectif est d'endormir les tâches. <br />
== Carte FPGA/VHDL ==<br />
<br />
<br />
Dans cette partie, nous devons implémenter un contrôleur de bus série SPI. <br />
<br />
Tout d'abord, voici comment fonctionne un bus SPI : <br />
<br />
Dans un bus SPI, il y a 1 maître et 1 ou plusieurs esclaves. Le transmission des données se font sur 2 fils : MISO et MOSI : <br />
<br />
- MOSI : Données du maître vers l'esclave,<br />
<br />
- MISO : Données de l'esclave vers le maître.<br />
<br />
Puisqu'il y a plusieurs esclaves, le SS (Ship Select) permet d'autoriser 1 esclaves précis en l'activant à 0. <br />
<br />
Les échanges se font sur front et sont synchronisés par le maître. <br />
<br />
Lorsqu'un octet du maître passe dans le registre de l'escalve, celui de l'esclave passe dans le registre du maître simultanément comme représenté sur l'image ci-dessous.<br />
[[Fichier:Chemin spi.png|centré|sans_cadre]]<br />
<br />
== Carte électronique numérique ==<br />
<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
=== Schéma Électronique ===<br />
Voici le schéma électronique fini de notre carte <br />
<br />
Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches, <br />
* 2 Leds de test + 1 Led d'alimentation<br />
* un ATmega328p<br />
* un connecteur HE10 8 pins pour un bus SPI + une ligne d'interruption pour communiquer avec la carte mère<br />
* un connecteur 6 pins(2x3) pour un bus SPI afin de programmer la carte.<br />
La programmation de notre carte se fera via un AVR ISP <br />
<br />
Pour cela, on utilise une carte arduino uno dans laquelle on televerse le programme Arduino ISP, disponible dans les exemples de l'IDE arduino, pour permettre a l'arduino uno d'envoyer notre code vers la carte clavier via le bus SPI. <br />
<br />
[[Fichier:Schéma AVR ISP.png|centré|vignette|400x400px]]<br />
Pour flasher notre carte clavier 2 solutions : <br />
<br />
* utiliser l'IDE arduino, en utilisant le paramètre "upload using programmer" qui permet de televerser du code dans une atmega en passant par le bus SPI. Mais cela néccesite d'écrire le code sur l'IDE arduino. Cette solution permettra simplement de faire des testes rapides en utilisant par exemple l'exemple Blink.<br />
* Créer un Makefil qui permet de televerser notre code C vers la carte fille en passant par l'arduino uno :<br />
<br />
[[Fichier:Makefil.png|centré|cadre]]<br />
Les résistances de pull up serviront à avoir un 1L par défaut puisque les lignes sont des sorties sur lesquelles nous écriront un 0L sur chaque sortie l'une après l'autre. Les colonnes sont des entrées, lorsqu'on lira un 0L sur une des colonnes, alors il suffira de voir laquelle des lignes est à 0L et ainsi connaitre le bouton qui est appuyé. <br />
[[Fichier:Schematique_clavier.png|centré|sans_cadre|511x511px]] <br />
<br />
Voici le routage de la schématique : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal. <br />
<br />
<br />
[[Fichier:Routage fini.png|sans_cadre]][[Fichier:3d view.png|sans_cadre|235x235px]][[Fichier:3d view bottom.png|sans_cadre|235x235px]] <br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réél clavier avec toutes les touches (ici 32) : <br />
[[Fichier:Carte_soude.jpg|centré|sans_cadre|383x383px]]<br />
<br />
<br />
Nous somme ensuite passée au différents testes de la carte : <br />
<br />
====== <u>Premier test : la carte est elle programmable ?</u> ======<br />
On utilise un programme très simple qui allume une des LEDs de la carte, le Blink disponible dans les exemple de l'IDE arduino.<br />
<br />
Mais en essayant de programmer la carte, aucune LEDs ne glignotait. Nous avons donc tester notre carte au multimètre. Il y avait un court-circuit au niveau du crystal qui empechait forcement son fonctionnement. l'erreur vient de notre footprint qui était décalé a 90°. Pour remedier a notre problème, nous avons désouder le crystal et l'avons tourné de 90°.<br />
<br />
Une fois le crystal resoudé dans la bon sens, nous avons pu flasher la carte clavier avec le programme Blink<br />
[[Fichier:Led_allumee_clavier.png|centré|sans_cadre|241x241px]]<br />
<br />
<br />
La LED est allumé, ce qui nous permet de valider le faite que la carte est programmable via notre AVR ISP<br />
<br />
====== <u>Deuxième test : la lecture des boutons</u> ======<br />
Pour commencer les testes, nous cherchons à allumer une led quand on appuie sur n'importe quel bouton. Pour cela on nous avons programmer notre matrice de LED : <br />
<br />
[[Fichier:Test clavier.png|centré|vignette]] <br />
<br />
[[Fichier:Premier_test_clavier.mp4|néant|cadre]]<br />
<br />
<br />
<br />
Dans notre code, nous avons fait en sorte d'avoir les boutons dans l'ordre alphabétique, c'est la raison pour laquelle les lettres ne sont pas dans l'odre dans notre code : <br />
<br />
[[Fichier:Boutons alphabétique.png|sans_cadre|300x300px]]<br />
<br />
Nous voulions mettre notre clavier en AZERTY, malheureusement notre matrice ne nous le permet pas. <br />
<br />
<br />
<br />
Par la suite, l'idée est d'envoyer les boutons appuyés à la carte mère via l'ISP. Pour cela, lorsque l'ISP enverra les octets 0x01 nous devrons envoyer le nombre de touches qui ont été appuyés depuis la dernière fois qu'il a envoyé cet octet. Après ça, la carte mère devra nous envoyer autre chose que 0x00 ou 0x01 et autant de fois que de touches touchées. Voici un exemple :<br />
<br />
Carte mère : 0x01<br />
<br />
Clavier : 2 (2 touches ont été touchées)<br />
<br />
Carte mère : 0x00<br />
<br />
Clavier : 'M'<br />
<br />
Carte mère : 0x00<br />
<br />
Clavier : 'S'<br />
<br />
Aussi, il se peut que la carte mère envoie l'octet 0x00, dans ce cas c'est une demande d'identification, alors la clavier devra répondre 0x1.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Test_clavier.png&diff=2647Fichier:Test clavier.png2024-01-10T11:42:50Z<p>Skaderis : </p>
<hr />
<div>code qui permet d'allumer une led si on appuie sur un bouton</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Makefil.png&diff=2646Fichier:Makefil.png2024-01-10T11:05:42Z<p>Skaderis : </p>
<hr />
<div>makefil pour utiliser l'AVR ISP et flasher la carte clavier</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Sch%C3%A9ma_AVR_ISP.png&diff=2645Fichier:Schéma AVR ISP.png2024-01-10T10:32:52Z<p>Skaderis : </p>
<hr />
<div>schéma</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2296SE4Binome2023-52023-12-07T10:09:36Z<p>Skaderis : /* Schéma Électronique */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Nous avons commencé par souder le redresseur de niveau, le lecteur de carte puis les résistances et les Leds : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre]]<br />
<br />
Également, nous avons partiellement soudé la carte de Leds suivante : <br />
<br />
[[Fichier:CartePin.png|sans_cadre]]<br />
<br />
Puis, nous avons soudé entièrement la carte 7 segments comme suit : <br />
<br />
[[Fichier:7_segments.png|sans_cadre]]<br />
<br />
Et pour finir, la carte Shield est entièrement soudée : <br />
<br />
[[Fichier:Shield.png|sans_cadre]][[Fichier:Back.png|sans_cadre]]<br />
<br />
<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino : <br />
<br />
[[Fichier:Câbles.png|sans_cadre]]<br />
<br />
<br />
=== Programmation ===<br />
[[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente. <br />
<br />
Les temps ne sont pas réels, c'est pour ça que l'objectif est d'endormir les tâches. <br />
== Carte FPGA/VHDL ==<br />
== Carte électronique numérique ==<br />
<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
=== Schéma Électronique ===<br />
Voici le schéma électronique fini de notre carte <br />
<br />
Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches, <br />
* 2 Leds de test + 1 Led d'alimentation, <br />
* une ISP pour communiquer avec la carte mère<br />
* la programmation de notre microcontrôleur se fera via un AVR ISP<br />
<br />
Les résistances de pull up serviront à avoir un 1L par défaut puisque les lignes sont des sorties sur lesquelles nous écriront un 0L sur chaque sortie l'une après l'autre. Les colonnes sont des entrées, lorsqu'on lira un 0L sur une des colonnes, alors il suffira de voir laquelle des lignes est à 0L et ainsi connaitre le bouton qui est appuyé. <br />
[[Fichier:Premier test clavier.mp4|néant|cadre]]<br />
[[Fichier:Schematique clavier.png|sans_cadre]] <br />
<br />
Voici le routage de la schématique : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal. <br />
<br />
<br />
[[Fichier:Routage fini.png|sans_cadre]]<br />
<br />
Suite à une erreur dans la schématique sur le crystal, il a été nécessaire de tourner à 90° pour le souder, sans ça on créait un court-circuit qui ne permet plus d'utiliser la carte. <br />
<br />
[[Fichier:3d view.png|sans_cadre]][[Fichier:3d view bottom.png|sans_cadre]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réél clavier avec toutes les touches (ici 32) : <br />
[[Fichier:Carte soude.jpg|gauche|vignette]] <br />
<br />
<br />
<br />
Afin de vérifier si la carte fonctionne, on a utilisé un Arduino Uno pour pouvoir téléverser un programme sur la carte du clavier. Pour se faire, on a inséré un programme Arduino "ArduinoISP" pour "transformer" la carte Arduino en ISP. Après ça, nous avons chargé le programme exemple "Blink" qui permet de faire clignoter des Leds. Nous avons alors fait clignoté la Led 8 : <br />
<br />
[[Fichier:Led allumee clavier.png|sans_cadre]]<br />
<br />
<br />
<br />
Après de multiples test au niveau programmation sur les boutons, rien ne fonctionnait. Alors nous avons vérifié si nos soudures étaient bonnes grâce au multimètre. Alors nous avons remarqué que chaque pin du bouton (les 4). Nous nous sommes alors rendu compte que nous avons fait une erreur lors de la création de nos footprint. Nos boutons étaient mal soudés et il a fallut dessouder puis ressouder chaque boutons en les tournant de 90°, ça n'a pas été facile puisqu'il a fallut plier et bouger les pins pour que le bouton rentre bien dans les trous. <br />
<br />
Finalement, nous avons fait un petit code qui permet d'allumer une led lorsque l'on appuie sur le bouton en bas à gauche de la carte afin de tester nos boutons. <br />
<br />
VIDEO BOUTON ET LED<br />
<br />
<br />
Par la suite, l'idée est d'envoyer les boutons appuyés à la carte mère via l'ISP. Pour cela, lorsque l'ISP enverra les octets 0x01 nous devrons envoyer le nombre de touches qui ont été appuyés depuis la dernière fois qu'il a envoyé cet octet. Après ça, la carte mère devra nous envoyer autre chose que 0x00 ou 0x01 et autant de fois que de touches touchées. Voici un exemple :<br />
<br />
Carte mère : 0x01<br />
<br />
Clavier : 2 (2 touches ont été touchées)<br />
<br />
Carte mère : 0x00<br />
<br />
Clavier : 'M'<br />
<br />
Carte mère : 0x00<br />
<br />
Clavier : 'S'<br />
<br />
Aussi, il se peut que la carte mère envoie l'octet 0x00, dans ce cas c'est une demande d'identification, alors la clavier devra répondre 0x1.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Carte_soude.jpg&diff=2294Fichier:Carte soude.jpg2023-12-07T10:08:45Z<p>Skaderis : </p>
<hr />
<div>photo de la carte clavier avec tout les composants soudées</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2287SE4Binome2023-52023-12-07T10:00:14Z<p>Skaderis : /* Programmation */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Nous avons commencé par souder le redresseur de niveau, le lecteur de carte puis les résistances et les Leds : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre]]<br />
<br />
Également, nous avons partiellement soudé la carte de Leds suivante : <br />
<br />
[[Fichier:CartePin.png|sans_cadre]]<br />
<br />
Puis, nous avons soudé entièrement la carte 7 segments comme suit : <br />
<br />
[[Fichier:7_segments.png|sans_cadre]]<br />
<br />
Et pour finir, la carte Shield est entièrement soudée : <br />
<br />
[[Fichier:Shield.png|sans_cadre]][[Fichier:Back.png|sans_cadre]]<br />
<br />
<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino : <br />
<br />
[[Fichier:Câbles.png|sans_cadre]]<br />
<br />
<br />
=== Programmation ===<br />
[[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente. <br />
<br />
Les temps ne sont pas réels, c'est pour ça que l'objectif est d'endormir les tâches. <br />
== Carte FPGA/VHDL ==<br />
== Carte électronique numérique ==<br />
<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
=== Schéma Électronique ===<br />
Voici le schéma électronique fini de notre carte <br />
<br />
Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches, <br />
* 2 Leds de test + 1 Led d'alimentation, <br />
* une ISP pour communiquer avec la carte mère<br />
* la programmation de notre microcontrôleur se fera via un AVR ISP<br />
<br />
Les résistances de pull up serviront à avoir un 1L par défaut puisque les lignes sont des sorties sur lesquelles nous écriront un 0L sur chaque sortie l'une après l'autre. Les colonnes sont des entrées, lorsqu'on lira un 0L sur une des colonnes, alors il suffira de voir laquelle des lignes est à 0L et ainsi connaitre le bouton qui est appuyé. <br />
[[Fichier:Premier test clavier.mp4|néant|cadre]]<br />
[[Fichier:Schematique clavier.png|sans_cadre]] <br />
<br />
Voici le routage de la schématique : Tous les condensateurs se trouvent à côté d'un VCC, le crystal est au plus proche du microcontrôleur et nous avons pris soin d'avoir des longueurs de pistes égales sur XTAL1 et XTAL2 du Crystal. <br />
<br />
<br />
[[Fichier:Routage fini.png|sans_cadre]]<br />
<br />
Suite à une erreur dans la schématique sur le crystal, il a été nécessaire de tourner à 90° pour le souder, sans ça on créait un court-circuit qui ne permet plus d'utiliser la carte. <br />
<br />
[[Fichier:3d view.png|sans_cadre]][[Fichier:3d view bottom.png|sans_cadre]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réél clavier avec toutes les touches (ici 32) : <br />
<br />
<br />
<br />
PHOTO CARTE SOUDEE <br />
<br />
<br />
Afin de vérifier si la carte fonctionne, on a utilisé un Arduino Uno pour pouvoir téléverser un programme sur la carte du clavier. Pour se faire, on a inséré un programme Arduino "ArduinoISP" pour "transformer" la carte Arduino en ISP. Après ça, nous avons chargé le programme exemple "Blink" qui permet de faire clignoter des Leds. Nous avons alors fait clignoté la Led 8 : <br />
<br />
[[Fichier:Led allumee clavier.png|sans_cadre]]<br />
<br />
<br />
<br />
Après de multiples test au niveau programmation sur les boutons, rien ne fonctionnait. Alors nous avons vérifié si nos soudures étaient bonnes grâce au multimètre. Alors nous avons remarqué que chaque pin du bouton (les 4). Nous nous sommes alors rendu compte que nous avons fait une erreur lors de la création de nos footprint. Nos boutons étaient mal soudés et il a fallut dessouder puis ressouder chaque boutons en les tournant de 90°, ça n'a pas été facile puisqu'il a fallut plier et bouger les pins pour que le bouton rentre bien dans les trous. <br />
<br />
Finalement, nous avons fait un petit code qui permet d'allumer une led lorsque l'on appuie sur le bouton en bas à gauche de la carte afin de tester nos boutons. <br />
<br />
VIDEO BOUTON ET LED</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Premier_test_clavier.mp4&diff=2286Fichier:Premier test clavier.mp42023-12-07T09:54:06Z<p>Skaderis : </p>
<hr />
<div>premier test des boutons du clavier</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2283SE4Binome2023-52023-12-07T09:36:54Z<p>Skaderis : /* Programmation */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Nous avons commencé par souder le redresseur de niveau, le lecteur de carte puis les résistances et les Leds : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre]]<br />
<br />
Également, nous avons partiellement soudé la carte de Leds suivante : <br />
<br />
[[Fichier:CartePin.png|sans_cadre]]<br />
<br />
Puis, nous avons soudé entièrement la carte 7 segments comme suit : <br />
<br />
[[Fichier:7_segments.png|sans_cadre]]<br />
<br />
Et pour finir, la carte Shield est entièrement soudée : <br />
<br />
[[Fichier:Shield.png|sans_cadre]][[Fichier:Back.png|sans_cadre]]<br />
<br />
<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino : <br />
<br />
[[Fichier:Câbles.png|sans_cadre]]<br />
<br />
<br />
=== Programmation ===<br />
[[Fichier:Ordonnanceur 1er test.mp4|centré|vignette]]<br />
Nous avons écris un programme d'ordonnancement qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente. <br />
<br />
<br />
VIDEO LEDS QUI CLIGNOTENT <br />
<br />
Les temps ne sont pas réels, c'est pour ça que l'objectif est d'endormir les tâches. <br />
<br />
== Carte FPGA/VHDL ==<br />
== Carte électronique numérique ==<br />
<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
=== Schéma Électronique ===<br />
Voici le schéma électronique fini de notre carte <br />
<br />
Nous avons opté pour : <br />
<br />
* une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches, <br />
* 2 Leds de test + 1 Led d'alimentation, <br />
* une ISP. <br />
<br />
Les résistances de pull up serviront avoir un 1L par défaut puisque les lignes sont des sorties sur lesquelles nous écriront un 0L sur chaque sortie l'une après l'autre. Les colonnes sont des entrées, lorsqu'on lira un 0L sur une des colonnes, alors il suffira de voir laquelle des lignes est à 0L et ainsi connaitre le bouton qui est appuyé. <br />
<br />
[[Fichier:Schematique clavier.png|sans_cadre]] <br />
<br />
Voici le routage de la schématique : Tous les condensateurs se trouvent à côté d'un VCC, le crystal se situe également à côté de ses Pins et nous avons pris soin d'avoir des tailles égales sur XTAL1 et XTAL2 du Crystal. <br />
<br />
<br />
[[Fichier:Routage fini.png|sans_cadre]]<br />
<br />
Suite à une erreur dans la schématique sur le crystal, il a été nécessaire de tourner à 90° pour le souder, sans ça on créait un court-circuit qui ne permet plus d'utiliser la carte. <br />
<br />
[[Fichier:3d view.png|sans_cadre]][[Fichier:3d view bottom.png|sans_cadre]]<br />
<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec tous les composants. On retrouve finalement l'allure d'un réél clavier avec toutes les touches (ici 32) : <br />
<br />
<br />
<br />
PHOTO CARTE SOUDEE <br />
<br />
<br />
Afin de vérifier si la carte fonctionne, on a utilisé un Arduino Uno pour pouvoir téléverser un programme sur la carte du clavier. Pour se faire, on a inséré un programme Arduino "ArduinoISP" pour "transformer" la carte Arduino en ISP. Après ça, nous avons chargé le programme exemple "Blink" qui permet de faire clignoter des Leds. Nous avons alors fait clignoté la Led 8 : <br />
<br />
[[Fichier:Led allumee clavier.png|sans_cadre]]<br />
<br />
<br />
<br />
Après de multiples test au niveau programmation sur les boutons, rien ne fonctionnait. Alors nous avons vérifié si nos soudures étaient bonnes grâce au multimètre. Alors nous avons remarqué que chaque pin du bouton (les 4). Nous nous sommes alors rendu compte que nous avons fait une erreur lors de la création de nos footprint. Nos boutons étaient mal soudés et il a fallut dessouder puis ressouder chaque boutons en les tournant de 90°, ça n'a pas été facile puisqu'il a fallut plier et bouger les pins pour que le bouton rentre bien dans les trous. <br />
<br />
Finalement, nous avons fait un petit code qui permet d'allumer une led lorsque l'on appuie sur le bouton en bas à gauche de la carte afin de tester nos boutons. <br />
<br />
VIDEO BOUTON ET LED</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ordonnanceur_1er_test.mp4&diff=2282Fichier:Ordonnanceur 1er test.mp42023-12-07T09:33:28Z<p>Skaderis : </p>
<hr />
<div>clignotement LED ordonnanceur</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-5&diff=2173SE4Binome2023-52023-11-28T17:07:45Z<p>Skaderis : /* Schéma Électronique */</p>
<hr />
<div><br />
<br />
Voici le lien de notre Git : https://archives.plil.fr/mnorman1/PICO.git<br />
Puis le zip de notre routage (vérifié par M. Redon) : [[Fichier:Gerber B5.zip|gauche|cadre]] <br />
<br />
== Ordonnanceur ==<br />
<br />
=== Soudure ===<br />
Nous avons commencé par souder le redresseur de niveau, le lecteur de carte puis les résistances et les Leds : <br />
<br />
[[Fichier:SHIELD.png|sans_cadre]]<br />
<br />
Également, nous avons partiellement soudé la carte de Leds suivante : <br />
<br />
[[Fichier:CartePin.png|sans_cadre]]<br />
<br />
Puis, nous avons soudé entièrement la carte 7 segments comme suit : <br />
<br />
[[Fichier:7_segments.png|sans_cadre]]<br />
<br />
Et pour finir, la carte Shield est entièrement soudée : <br />
<br />
[[Fichier:Shield.png|sans_cadre]][[Fichier:Back.png|sans_cadre]]<br />
<br />
<br />
<br />
=== Câble pont Shield Arduino ===<br />
En parallèle, nous avons réalisé les câbles qui se situent entre la carte Shield et la carte Arduino : <br />
<br />
[[Fichier:Câbles.png|sans_cadre]]<br />
<br />
<br />
=== Programmation ===<br />
Nous avons écris un programme qui permet de faire clignoter 2 Leds (Led1 et Led2) avec une durée différente. <br />
<br />
<br />
VIDEO LEDS QUI CLIGNOTENT <br />
<br />
== Carte FPGA/VHDL ==<br />
== Carte électronique numérique ==<br />
<br />
<br />
== Type de carte choisie ==<br />
Nous avons choisi de travailler sur la carte fille clavier "'''matrice de touches'''"<br />
<br />
=== Schéma Électronique ===<br />
Voici le schéma électronique fini de notre carte <br />
<br />
Nous avons opté pour une matrice de touches de 4 par 8, ce qui nous fait 32 touches soient les 26 lettres de l'alphabet + 6 autre touches. <br />
<br />
[[Fichier:Schematique clavier.png|sans_cadre]] <br />
<br />
Voici le routage de la schématique : Tous les condensateurs se toruvent à côté d'un VCC, le crystal se situe également à côté de ses Pins et nous avons pris soin d'avoir (à peu près) des tailles égales sur XTAL1 et XTAL2 du Crystal. <br />
<br />
<br />
[[Fichier:Routage fini.png|sans_cadre]]<br />
<br />
Suite à une erreur dans la schématique sur le crystal, il a été nécessaire de tourner à 90° pour le souder, sans ça on créait un court-circuit qui ne permet plus d'utiliser la carte. <br />
<br />
[[Fichier:3d view.png|sans_cadre]][[Fichier:3d view bottom.png|sans_cadre]]<br />
<br />
<br />
Après avoir reçu la carte imprimée, nous l'avons directement soudée avec (pratiquement) tous les composants. On retrouve finalement l'allure d'un réél clavier avec toutes les touches (ici 32) : <br />
<br />
<br />
<br />
<br />
Afin de vérifier si la carte fonctionne, on a utilisé un Arduino Uno pour pouvoir téléverser un programme sur la carte du clavier. Pour se faire, on a inséré un programme Arduino "ArduinoISP" pour "transformer" la carte Arduino en ISP. Après ça, nous avons chargé le programme exemple "Blink" qui permet de faire clignoter des Leds. Nous avons alors fait clignoté la Led 8 : <br />
<br />
[[Fichier:Led allumee clavier.png|sans_cadre]]<br />
<br />
<br />
Lors du test de nos boutons, nous nous sommes rendu compte d'une erreur sur nos footprint de bouton. Nos boutons étaient mal câblé et il a fallut dessouder puis resouder chaque boutons en les tourant de 90°. <br />
<br />
Nous avons fait un petit code qui permet d'allumer une led lorsque l'on appuie sur le bouton en bas à gauche de la carte afin de tester nos boutons.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Carte_sous_int%C3%A9gralement_.jpg&diff=2065Fichier:Carte sous intégralement .jpg2023-11-15T07:46:01Z<p>Skaderis : </p>
<hr />
<div>La carte a était testé est soudé entièrement</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Trinome2022-6&diff=1182SE3Trinome2022-62023-06-04T15:08:30Z<p>Skaderis : /* Makefile */</p>
<hr />
<div>= Premier Système SE3 =<br />
Voici le lien de notre Git :<br />
<br />
https://archives.plil.fr/mnorman1/PSE_trinome_6<references /><br />
<br />
== Introduction et objectif ==<br />
Nous partons sur la voiture 1/43.<br />
<br />
Notre voiture comportera les éléments ci-dessous : <br />
<br />
* 2 moteurs pour le contrôle (1 DC à l'arrière et un pas à pas à l'avant),<br />
* 1 module Bluetooth,<br />
* des leds (4 : deux phares avants ainsi que deux arrières),<br />
* une batterie<br />
L'idée est, avec le module Bluetooth, de pouvoir piloter la voiture à distance. <br />
<br />
L'objectif à la fin des semaines de ce projet est d'être capable de gérer les différentes leds, les moteurs et d'avoir une batterie fonctionnelle. <br />
<br />
== Schéma électronique ==<br />
<br />
Pour faire notre schéma électronique ainsi que notre routage, nous avons utilisé le logiciel Kikad. <br />
<br />
Vous trouverez différentes blocs : <br />
<br />
* L'ATMega16u2 qui est alimenté en +5V<br />
* L'alimentation et la charge batterie, avec un ''MAX1811'' et un USB pour brancher directement la carte sur le PC pour l'alimentation et le téléversement du programme en C.<br />
* Un bloc AVR qui est un connecteur femele pour se brancher directement à l'autre carte.<br />
* Les 4 leds (qui sont les phares de notre voiture)<br />
* Les moteurs : nous avons choisi d'utiliser un moteur pas à pas bipolaire et un moteur à courant continu (avec des PWM qui sont connectés aux Pins PWM du microcontroleur)<br />
* Le Bluetooth avec un ''BM71BLE01FC2'' (nous l'avons créé nous même sur Kikad) et son antenne (créée également par nous-même)<br />
<br />
[[Fichier:Schematique carte.png|vignette|Schéma entier|centré]]<br />
<br />
Nous avons choisi de créer un circuit à part pour l'AVR car il ne sera utilisé que pour la programmation et pas pour le fonctionnement de la voiture.[[Fichier:Schématique ISP.png|vignette|Schéma ISP|centré]]<br />
<br />
<br />
== Routage ==<br />
#Carte de la voiture<br />
<br />
<br />
<br />
La carte se connectera directement sur une prise USB pour téléverser le programme dans l'atMega16u2. Les deux faces sont des plans de masse, ce qui facile le routage. Pour faire notre routage, nous avons dû créer certains footprint tels que celui de l'antenne, du moteur continu et du ''BM71BLE01FC2'' (le module bluetooth).[[Fichier:Routage derniere version.png|vignette|Routage|centré]] [[Fichier:Vue 3D carte .png|vignette|Top|centré]] [[Fichier:Vue bottom.png|vignette|Bottom|centré]]<br />
#Carte de l'ISP<br />
<br />
[[Fichier:Routage ISP.png|Routage ISP|centré|sans_cadre]]<br />
<br />
== Carte imprimée ==<br />
Voici la carte imprimée et partiellement soudée (uC, Leds, moteur pas à pas, USB) : <br />
<br />
[[Fichier:Carte imprimée et soudée.png|centré|Carte imprimée|sans_cadre]]<br />
<br />
<u>Remarque :</u> un des pins du moteur n'a pas était relié au microcontrôleur lors du routage de la carte, nous avons donc connecté un fil entre le moteur et la pin 25 du microcontrôleur. <br />
<br />
Avant de souder tous les composants, l'idée est de vérifier si le PC détecte bien la carte. Pour pouvoir alimenter notre carte via l'usb sans avoir a souder le régulateur et ces condensateurs, nous avons simplement souder un fil entre le port USB et l'alimentation du microcontrôleur. <br />
== Carte fonctionnelle ==<br />
Premièrement, afin de vérifier si la carte est fonctionnelle nous n'avons soudé que l'atmega, le quartz et le port usb, pour s'assurer avec la commande "''lsusb"'' que la carte est bien vue par le PC. <br />
[[Fichier:Fonction lsusb.png|600x600px|Fonction lsusb|centré|sans_cadre]]<br />
<br />
On voit ici que l'atmega16u2 est bien détecté. <br />
<br />
Maintenant que l'on sait que notre carte fonctionne, on peut passer à la partie programmation des différents composants de la voiture.<br />
== Programmation ==<br />
<br />
Les PINS dont nous allons avoir besoin sont les suivants : <br />
{| class="wikitable"<br />
|+<br />
|LED 1<br />
|B6/20<br />
|-<br />
|LED 2<br />
|B5/19<br />
|-<br />
|LED 3<br />
|B4/18<br />
|-<br />
|LED 4<br />
|B1/14<br />
|-<br />
|MOT1<br />
|D4/10<br />
|-<br />
|MOT2<br />
|D5/11<br />
|-<br />
|MOT3<br />
|D6/12<br />
|-<br />
|MOT4<br />
|C5/25<br />
|}<br />
<br />
=== Makefile ===<br />
Tout d'abord, nous avons écris notre Makefile comme ceci : <br />
[[Fichier:Makefile .png|centré|Makefile|sans_cadre]]<br />
<br />
=== Gestion des LEDS ===<br />
Nous avons repris la base du programme que nous avons utilisé en TPI (manette) pour configurer les Leds ainsi que le programme ''io.c'' pour utiliser les fonctions présentes dans celui-ci (''output_toogle(), output_set(), ...''). <br />
<br />
Nous avons également repris les configurations des Pins des entrées/sorties des Leds ainsi que les moteurs , comme ci-dessous. <br />
[[Fichier:Pins entrees sorties.png|centré|Config entree/sortie|sans_cadre]]<br />
Par la suite, afin de faire clignoter les Leds, voici le programme (fonctionnel) que nous avons écrit : <br />
[[Fichier:Programme leds.png|centré|Prog leds|sans_cadre]] <br />
<br />
=== Gestion du moteur pas à pas ===<br />
Pour poursuivre, afin de faire fonctionner le moteur pas à pas, nous avons fait quelques recherches pour la programmation. <br />
Pour ce faire, nous nous sommes aidés du chronogramme de l'activité du moteur bipolaire suivant : <br />
[[Fichier:Chronogramme des pas .png|centré|chrono des pas |sans_cadre]]<br />
<br />
Le fonctionnement est simple, les 4 pines du moteur sont connecté directement à 4 pattes du microcontrôleur. et il suffit alors de mettre à 1 chacune des sorties selon le chronogramme ci-dessus. <br />
<br />
Voici le code final fonctionnel du moteur pas à pas : <br />
[[Fichier:Code moteur pas à pas .png|centré|prog mots|sans_cadre]]<br />
On trouve l'initialisation des sorties avec DDRX, et la mise à 1 des sorties avec PORTX. On peut alors configurer les pins du microcontrôleur pour commander le moteur selon le chronogramme. <br />
<br />
Dans ce cas, le code permet au moteur de tourner dans un sens puis dans l'autre. <br />
<br />
=== USB/LUFA ===<br />
Par la suite, l'idée est de faire fonctionner le moteur directement avec les commandes de l'ordinateur. Pour se faire, on a récupéré les programmes faits en TPI Manette. <br />
<br />
Evidemment, nous devons changer quelques informations, telles que le idVendor et le idProduct. <br />
[[Fichier:Lsusb -vvv.png|centré|sans_cadre|lsusb -vvv]]<br />
Enfin, nous avons ajouter une fonction principale dans lib.c afin de controler, grâce aux octets, l'allumage des leds et du moteur : <br />
[[Fichier:Fonction lib.c.png|centré|sans_cadre]]<br />
Dans data[] : on a 2 octets : le premier qui sert à gérer les Leds et le moteur et la 2ème qu'on n'utilisera pas. <br />
<br />
Les 4 bits de poids faibles servent à allumer les Leds (chaque bit commande une led). <br />
<br />
Les 4 bits de poids forts servent à gérer le moteur(1 pour un un sens, 2 pour l'autre sens) <br />
<br />
Dans le fichier Voiture.c, on a repris les lignes de test_leds.c (notre programme de tests) et les avons mis dans la fonction HandlePCReceive() de Voiture.c. <br />
<br />
== Vidéos système ==<br />
Les vidéos étant trop lourdes, voici un lien Drive de nos vidéos : https://drive.google.com/drive/folders/1xb7-hz1aA-z115mloMOLafnvyD3ojA3p?usp=share_link <br />
<br />
== Conclusion ==<br />
A la fin du projet, notre carte est détectée par le PC, et nous sommes en mesure de programmer le microcontrôleur pour commander les leds et le moteur pas a pas. Il est également possible de commander les leds et le moteur via l'USB.<br />
<br />
<br />
<br />
La principale difficulté de ce projet à été la réalisation du PCB sur Kicad, où nous avons appris plusieurs aspects de la conception d'un PCB : <br />
<br />
- créer des footprint, en allant chercher les dimensions dans les datasheets.<br />
<br />
- s'assurer que notre schéma est cohérent, et que chaque composant est correctement câblé, sans quoi la carte finale n'a aucune chance de fonctionner.<br />
<br />
- rooter de manière cohérente, en prenant en compte les perturbations que chaque composants engendrent sur les autres, notamment au niveau de l'antenne.<br />
Ce projet nous a aussi permit d'apprendre a soudé des composants montés en surface (led, microcontrôleur, résistance). <br />
<br />
Nous avons aussi eu un problème lors de la soudure du moteur, où celui-ci a été endommagé, probablement à cause d'une exposition prolongée au fer à souder, qui a endommagé la bobine. <br />
<br />
La voiture est loin d'être finie, nous n'avons malheureusement pas pu traiter la partie Bluetooth et la partie batterie. Néanmoins, ce projet nous à permit d'avoir une première approche de ce en quoi consiste un projet de système embarqué, de sa conception, à sa réalisation, et nous somme maintenant bien plus à l'aise avec la créations des PCB et la programmation avec un microcontrôleur.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Trinome2022-6&diff=1169SE3Trinome2022-62023-06-04T14:15:02Z<p>Skaderis : /* Carte imprimée */</p>
<hr />
<div>= Premier Système SE3 =<br />
Voici le lien de notre Git :<br />
<br />
https://archives.plil.fr/mnorman1/PSE_trinome_6<references /><br />
<br />
== Introduction et objectif ==<br />
Nous partons sur la voiture 1/43.<br />
<br />
Notre voiture comportera les éléments ci-dessous : <br />
<br />
* 2 moteurs pour le contrôle (1 DC à l'arrière et un pas à pas à l'avant),<br />
* 1 module Bluetooth,<br />
* des leds (4 : deux phares avants ainsi que deux arrières),<br />
* une batterie<br />
L'idée est, avec le module Bluetooth, de pouvoir piloter la voiture à distance. <br />
<br />
L'objectif à la fin des semaines de ce projet est d'être capable de gérer les différentes leds, les moteurs et d'avoir une batterie fonctionnelle. <br />
<br />
== Schéma électronique ==<br />
<br />
Pour faire notre schéma électronique ainsi que notre routage, nous avons utilisé le logiciel Kikad. <br />
<br />
Vous trouverez différentes blocs : <br />
<br />
* L'ATMega16u2 qui est alimenté en +5V<br />
* L'alimentation et la charge batterie, avec un ''MAX1811'' et un USB pour brancher directement la carte sur le PC pour l'alimentation et le téléversement du programme en C.<br />
* Un bloc AVR qui est un connecteur femele pour se brancher directement à l'autre carte.<br />
* Les 4 leds (qui sont les phares de notre voiture)<br />
* Les moteurs : nous avons choisi d'utiliser un moteur pas à pas bipolaire et un moteur à courant continu (avec des PWM qui sont connectés aux Pins PWM du microcontroleur)<br />
* Le Bluetooth avec un ''BM71BLE01FC2'' (nous l'avons créé nous même sur Kikad) et son antenne (créée également par nous-même)<br />
<br />
[[Fichier:Schematique carte.png|vignette|Schéma entier|centré]]<br />
<br />
Nous avons choisi de créer un circuit à part pour l'AVR car il ne sera utilisé que pour la programmation et pas pour le fonctionnement de la voiture.[[Fichier:Schématique ISP.png|vignette|Schéma ISP|centré]]<br />
<br />
<br />
== Routage ==<br />
#Carte de la voiture<br />
<br />
<br />
<br />
La carte se connectera directement sur une prise USB pour téléverser le programme dans l'atMega16u2. Les deux faces sont des plans de masse, ce qui facile le routage. Pour faire notre routage, nous avons dû créer certains footprint tels que celui de l'antenne, du moteur continu et du ''BM71BLE01FC2'' (le module bluetooth).[[Fichier:Routage derniere version.png|vignette|Routage|centré]] [[Fichier:Vue 3D carte .png|vignette|Top|centré]] [[Fichier:Vue bottom.png|vignette|Bottom|centré]]<br />
#Carte de l'ISP<br />
<br />
[[Fichier:Routage ISP.png|Routage ISP|centré|sans_cadre]]<br />
<br />
== Carte imprimée ==<br />
Voici la carte imprimée et partiellement soudée (uC, Leds, moteur pas à pas, USB) : <br />
<br />
[[Fichier:Carte imprimée et soudée.png|centré|Carte imprimée|sans_cadre]]<br />
<br />
<u>Remarque :</u> un des pins du moteur n'a pas était relié au microcontrôleur lors du routage de la carte, nous avons donc connecté un fil entre le moteur et la pin 25 du microcontrôleur. <br />
<br />
Avant de souder tous les composants, l'idée est de vérifier si le PC détecte bien la carte. Pour pouvoir alimenter notre carte via l'usb sans avoir a souder le régulateur et ces condensateurs, nous avons simplement souder un fil entre le port USB et l'alimentation du microcontrôleur. <br />
== Carte fonctionnelle ==<br />
Premièrement, afin de vérifier si la carte est fonctionnelle nous n'avons soudé que l'atmega, le quartz et le port usb, pour s'assurer avec la commande "''lsusb"'' que la carte est bien vue par le PC. <br />
[[Fichier:Fonction lsusb.png|600x600px|Fonction lsusb|centré|sans_cadre]]<br />
<br />
On voit ici que l'atmega16u2 est bien détecté. <br />
<br />
Maintenant que l'on sait que notre carte fonctionne, on peut passer à la partie programmation des différents composants de la voiture.<br />
== Programmation ==<br />
<br />
Les PINS dont nous allons avoir besoin sont les suivants : <br />
{| class="wikitable"<br />
|+<br />
|LED 1<br />
|B6/20<br />
|-<br />
|LED 2<br />
|B5/19<br />
|-<br />
|LED 3<br />
|B4/18<br />
|-<br />
|LED 4<br />
|B1/14<br />
|-<br />
|MOT1<br />
|D4/10<br />
|-<br />
|MOT2<br />
|D5/11<br />
|-<br />
|MOT3<br />
|D6/12<br />
|-<br />
|MOT4<br />
|C5/25<br />
|}<br />
<br />
=== '''Makefile''' ===<br />
Tout d'abord, nous avons écris notre Makefile comme ceci : <br />
[[Fichier:Makefile .png|centré|Makefile|sans_cadre]]<br />
<br />
=== Gestion des LEDS ===<br />
Nous avons repris la base du programme que nous avons utilisé en TPI (manette) pour configurer les Leds ainsi que le programme ''io.c'' pour utiliser les fonctions présentes dans celui-ci (''output_toogle(), output_set(), ...''). <br />
<br />
Nous avons également repris les configurations des Pins des entrées/sorties des Leds ainsi que les moteurs , comme ci-dessous. <br />
[[Fichier:Pins entrees sorties.png|centré|Config entree/sortie|sans_cadre]]<br />
Par la suite, afin de faire clignoter les Leds, voici le programme (fonctionnel) que nous avons écrit : <br />
[[Fichier:Programme leds.png|centré|Prog leds|sans_cadre]] <br />
<br />
=== Gestion du moteur pas à pas ===<br />
Pour poursuivre, afin de faire fonctionner le moteur pas à pas, nous avons fait quelques recherches pour la programmation. <br />
Pour ce faire, nous nous sommes aidés du chronogramme de l'activité du moteur bipolaire suivant : <br />
[[Fichier:Chronogramme des pas .png|centré|chrono des pas |sans_cadre]]<br />
<br />
Le fonctionnement est simple, les 4 pines du moteur sont connecté directement à 4 pattes du microcontrôleur. et il suffit alors de mettre à 1 chacune des sorties selon le chronogramme ci-dessus. <br />
<br />
Voici le code final fonctionnel du moteur pas à pas : <br />
[[Fichier:Code moteur pas à pas .png|centré|prog mots|sans_cadre]]<br />
On trouve l'initialisation des sorties avec DDRX, et la mise à 1 des sorties avec PORTX. On peut alors configurer les pins du microcontrôleur pour commander le moteur selon le chronogramme. <br />
<br />
Dans ce cas, le code permet au moteur de tourner dans un sens puis dans l'autre. <br />
<br />
=== USB/LUFA ===<br />
Par la suite, l'idée est de faire fonctionner le moteur directement avec les commandes de l'ordinateur. Pour se faire, on a récupéré les programmes faits en TPI Manette. <br />
<br />
Evidemment, nous devons changer quelques informations, telles que le idVendor et le idProduct. <br />
[[Fichier:Lsusb -vvv.png|centré|sans_cadre|lsusb -vvv]]<br />
Enfin, nous avons ajouter une fonction principale dans lib.c afin de controler, grâce aux octets, l'allumage des leds et du moteur : <br />
[[Fichier:Fonction lib.c.png|centré|sans_cadre]]<br />
Dans data[] : on a 2 octets : le premier qui sert à gérer les Leds et le moteur et la 2ème qu'on n'utilisera pas. <br />
<br />
Les 4 bits de poids faibles servent à allumer les Leds (chaque bit commande une led). <br />
<br />
Les 4 bits de poids forts servent à gérer le moteur(1 pour un un sens, 2 pour l'autre sens) <br />
<br />
Dans le fichier Voiture.c, on a repris les lignes de test_leds.c (notre programme de tests) et les avons mis dans la fonction HandlePCReceive() de Voiture.c. <br />
<br />
== Vidéos système ==<br />
Les vidéos étant trop lourdes, voici un lien Drive de nos vidéos : https://drive.google.com/drive/folders/1xb7-hz1aA-z115mloMOLafnvyD3ojA3p?usp=share_link <br />
<br />
== Conclusion ==<br />
A la fin du projet, notre carte est détecté par le PC, et nous sommes en mesure de programmer le microcontrôleur pour commander les leds et le moteur pas a pas. Il est également possible de commander les leds et le moteur via l'USB.<br />
<br />
<br />
La principale difficulté de ce projet à était la réalisation du PCB sur Kicad, ou nous avons appris plusieurs aspects de la conception d'un PCB : <br />
<br />
- créer des footprint, en allant chercher les dimensions dans les datasheets.<br />
<br />
- s'assurer que notre schéma est cohérant, et que chaque composant est correctement câblé, sans quoi la carte final n'a aucune chance de fonctionner.<br />
<br />
- rooter de manière cohérant, en prenant en compte les perturbations que chaque composants engendre sur les autres, notamment au niveau de l'antenne.<br />
Ce projet nous a aussi permit d'apprendre a souder des composants monté en surface (led, microcontrôleur, résistance).<br />
<br />
Nous avons aussi eu un problème lors de la soudure du moteur, ou celui-ci à était endommagé, probablement à cause d'une exposition prolongé au fer à souder, qui a endommagé la bobine.<br />
<br />
La voiture est loin d'être fini, nous n'avons malheureusement pas pu traiter la partie Bluetooth et la partie batterie. Néanmoins, ce projet nous à permit d'avoir une première approche de ce en quo consiste un projet de système embarqué, de sa conception, à sa réalisation, et nous somme maintenant bien plus à l'aise avec la créations des PCB.</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Trinome2022-6&diff=1144SE3Trinome2022-62023-06-04T13:29:14Z<p>Skaderis : /* Programmation */</p>
<hr />
<div>= Premier Système SE3 =<br />
Voici le lien de notre Git :<br />
<br />
https://archives.plil.fr/mnorman1/PSE_trinome_6<references /><br />
<br />
== Introduction et objectif ==<br />
Nous partons sur la voiture 1/43.<br />
<br />
Voici le modèle de carte de que nous choisissons :<br />
<br />
* 2 moteurs pour le contrôle (1 DC à l'arrière et un pas à pas à l'avant),<br />
* 1 module Bluetooth,<br />
* des leds (4 : deux phares avants ainsi que deux arrières),<br />
* une batterie<br />
L'idée est, avec le module Bluetooth, de pouvoir piloter la voiture grâce à une application mobile. <br />
<br />
L'objectif à la fin des semaines de ce projet est d'être capable de gérer les différentes leds, les moteurs et d'avoir une batterie fonctionnelle. <br />
<br />
== Schéma électronique ==<br />
<br />
Pour faire notre schéma électronique ainsi que notre routage, nous avons utilisé le logiciel Kikad. <br />
<br />
Vous trouverez différentes blocs : <br />
<br />
* L'ATMega16u2 qui est alimenté en +5V<br />
* L'alimentation et la charge batterie, avec un ''MAX1811'' et un USB pour brancher directement la carte sur le PC pour l'alimentation et le téléversement du programme en C.<br />
* Un bloc AVR qui est un connecteur femele pour se brancher directement à l'autre carte.<br />
* Les 4 leds (qui sont les phares de notre voiture)<br />
* Les moteurs : nous avons choisi d'utiliser un moteur pas à pas bipolaire et un moteur à courant continu (avec des PWM qui sont connectés aux Pins PWM du microcontroleur)<br />
* Le Bluetooth avec un ''BM71BLE01FC2'' (nous l'avons créé nous même sur Kikad) et son antenne (créée également par nous-même)<br />
<br />
[[Fichier:Schematique carte.png|vignette|Schéma entier|centré]]<br />
<br />
Nous avons choisi de créer un circuit à part pour l'AVR car il ne sera utilisé que pour la programmation et pas pour le fonctionnement de la voiture.[[Fichier:Schématique ISP.png|vignette|Schéma ISP|centré]]<br />
<br />
<br />
== Routage ==<br />
#Carte de la voiture<br />
<br />
<br />
<br />
La carte se connectera directement sur une prise USB pour téléverser le programme dans l'atMega16u2. Les deux faces sont des plans de masse, ce qui facile le routage. Pour faire notre routage, nous avons dû créer certains footprint tels que celui de l'antenne, du moteur continu et du ''BM71BLE01FC2'' (le module bluetooth).[[Fichier:Routage derniere version.png|vignette|Routage|centré]] [[Fichier:Vue 3D carte .png|vignette|Top|centré]] [[Fichier:Vue bottom.png|vignette|Bottom|centré]]<br />
#Carte de l'ISP<br />
<br />
[[Fichier:Routage ISP.png|Routage ISP|centré|sans_cadre]]<br />
<br />
== Carte imprimée ==<br />
Voici la carte imprimée et partiellement soudée (uC, Leds, moteur pas à pas, USB) : <br />
<br />
[[Fichier:Carte imprimée et soudée.png|centré|Carte imprimée|sans_cadre]]<br />
<br />
Avant de souder tous les composants, l'idée était de vérifier si le PC détectait bien la carte, nous avons dû souder un fil sur le Pin 4 et le Pin 5 pour pouvoir alimenter l'ATMega16u2. <br />
== Carte fonctionnelle ==<br />
Premièrement, afin de vérifier si la carte est fonctionnelle nous n'avons soudé que l'atmega, le quartz et le port usb, pour s'assurer avec la commande "''lsusb"'' que la carte est bien vue par le PC. <br />
[[Fichier:Fonction lsusb.png|600x600px|Fonction lsusb|centré|sans_cadre]]<br />
<br />
On voit ici que l'atmega16u2 est bien détecté. <br />
<br />
Maintenant que l'on sait que notre carte fonctionne, on peut passer à la partie programmation des différents composants de la voiture.<br />
== Programmation ==<br />
<br />
Les PINS dont nous allons avoir besoin sont les suivants : <br />
{| class="wikitable"<br />
|+<br />
|LED 1<br />
|B6/20<br />
|-<br />
|LED 2<br />
|B5/19<br />
|-<br />
|LED 3<br />
|B4/18<br />
|-<br />
|LED 4<br />
|B1/14<br />
|-<br />
|MOT1<br />
|D4/10<br />
|-<br />
|MOT2<br />
|D5/11<br />
|-<br />
|MOT3<br />
|D6/12<br />
|-<br />
|MOT4<br />
|C5/25<br />
|}<br />
<br />
=== '''Makefile''' ===<br />
Tout d'abord, nous avons écris notre Makefile comme ceci : <br />
[[Fichier:Makefile .png|centré|Makefile|sans_cadre]]<br />
<br />
=== Gestion des LEDS ===<br />
Nous avons repris la base du programme que nous avons utilisé en TPI (manette) pour configurer les Leds ainsi que le programme ''io.c'' pour utiliser les fonctions présentes dans celui-ci (''output_toogle(), output_set(), ...''). <br />
<br />
Nous avons également repris les configurations des Pins des entrées/sorties des Leds ainsi que les moteurs , comme ci-dessous. <br />
[[Fichier:Pins entrees sorties.png|centré|Config entree/sortie|sans_cadre]]<br />
Par la suite, afin de faire clignoter les Leds, voici le programme (fonctionnel) que nous avons écrit : <br />
[[Fichier:Programme leds.png|centré|Prog leds|sans_cadre]] <br />
<br />
=== Gestion du moteur pas à pas ===<br />
Pour poursuivre, afin de faire fonctionner le moteur pas à pas, nous avons fait quelques recherches pour la programmation. <br />
Pour ce faire, nous nous sommes aidés du chronogramme de l'activité du moteur bipolaire suivant : <br />
[[Fichier:Chronogramme des pas .png|centré|chrono des pas |sans_cadre]]<br />
<br />
Le fonctionnement est simple, les 4 pines du moteur sont connecté directement à 4 pattes du microcontrôleur. et il suffit alors de mettre à 1 chacune des sorties selon le chronogramme ci-dessus. <br />
<br />
Voici le code final fonctionnel du moteur pas à pas : <br />
[[Fichier:Code moteur pas à pas .png|centré|prog mots|sans_cadre]]<br />
On trouve l'initialisation des sorties avec DDRX, et la mise à 1 des sorties avec PORTX. On peut alors configurer les pins du microcontrôleur pour commander le moteur selon le chronogramme. <br />
<br />
Dans ce cas, le code permet au moteur de tourner dans un sens puis dans l'autre. <br />
<br />
=== USB/LUFA ===<br />
Par la suite, l'idée est de faire fonctionner le moteur directement avec les commandes de l'ordinateur. Pour se faire, on a récupéré les programmes faits en TPI Manette. <br />
<br />
Evidemment, nous devons changer quelques informations, telles que le idVendor et le idProduct. <br />
[[Fichier:Lsusb -vvv.png|centré|sans_cadre|lsusb -vvv]]<br />
Enfin, nous avons ajouter une fonction principale dans lib.c afin de controler, grâce aux octets, l'allumage des leds et du moteur : <br />
[[Fichier:Fonction lib.c.png|centré|sans_cadre]]<br />
Dans data[] : on a 2 octets : le premier qui sert à gérer les Leds et le moteur et la 2ème qu'on n'utilisera pas. <br />
<br />
Les 4 bits de poids faibles servent à allumer les Leds (chaque bit commande une led). <br />
<br />
Les 4 bits de poids forts servent à gérer le moteur(1 pour un un sens, 2 pour l'autre sens) <br />
<br />
Dans le fichier Voiture.c, on a repris les lignes de test_leds.c (notre programme de tests) et les avons mis dans la fonction HandlePCReceive() de Voiture.c. <br />
<br />
== Vidéos système ==<br />
Les vidéos étant trop lourdes, voici un lien Drive de nos vidéos : https://drive.google.com/drive/folders/1xb7-hz1aA-z115mloMOLafnvyD3ojA3p?usp=share_link <br />
<br />
== Conclusion ==<br />
A la fin du projet, notre carte est détecté par le PC, et nous sommes en mesure de programmer le microcontrôleur pour commander les leds et le moteur pas a pas. Il est également possible de commander les leds et le moteur via l'USB.<br />
<br />
<br />
La principale difficulté de ce projet à était la réalisation du PCB sur Kicad, ou nous avons appris plusieurs aspects de la conception d'un PCB : <br />
<br />
- créer des footprint, en allant chercher les dimensions dans les datasheets.<br />
<br />
- s'assurer que notre schéma est cohérant, et que chaque composant est correctement câblé, sans quoi la carte final n'a aucune chance de fonctionner.<br />
<br />
- rooter de manière cohérant, en prenant en compte les perturbations que chaque composants engendre sur les autres, notamment au niveau de l'antenne.<br />
Ce projet nous a aussi permit d'apprendre a souder des composants monté en surface (led, microcontrôleur, résistance).</div>Skaderishttps://projets-se.plil.fr/mediawiki/index.php?title=SE3Trinome2022-6&diff=953SE3Trinome2022-62023-06-03T12:59:30Z<p>Skaderis : /* Conclusion */</p>
<hr />
<div>= Premier Système SE3 =<br />
Voici le lien de notre Git :<br />
<br />
https://archives.plil.fr/mnorman1/PSE_trinome_6<references /><br />
<br />
== Introduction et objectif ==<br />
Nous partons sur la voiture 1/43.<br />
<br />
Voici le modèle de carte de que nous choisissons :<br />
<br />
* 2 moteurs pour le contrôle (1 DC à l'arrière et un pas à pas à l'avant),<br />
* 1 module Bluetooth,<br />
* des leds (4 : deux phares avants ainsi que deux arrières),<br />
* une batterie<br />
L'idée est, avec le module Bluetooth, de pouvoir piloter la voiture grâce à une application mobile. <br />
<br />
L'objectif à la fin des semaines de ce projet est d'être capable de gérer les différentes leds, les moteurs et d'avoir une batterie fonctionnelle. <br />
<br />
== Schéma électronique ==<br />
<br />
Pour faire notre schéma électronique ainsi que notre routage, nous avons utilisé le logiciel Kikad. <br />
<br />
Vous trouverez différentes blocs : <br />
<br />
* L'ATMega16u2 qui est alimenté en +5V<br />
* L'alimentation et la charge batterie, avec un ''MAX1811'' et un USB pour brancher directement la carte sur le PC pour l'alimentation et le téléversement du programme en C.<br />
* Un bloc AVR qui est un connecteur femele pour se brancher directement à l'autre carte.<br />
* Les 4 leds (qui sont les phares de notre voiture)<br />
* Les moteurs : nous avons choisi d'utiliser un moteur pas à pas bipolaire et un moteur à courant continu (avec des PWM qui sont connectés aux Pins PWM du microcontroleur)<br />
* Le Bluetooth avec un ''BM71BLE01FC2'' (nous l'avons créé nous même sur Kikad) et son antenne (créée également par nous-même)<br />
<br />
[[Fichier:Schematique carte.png|vignette|Schéma entier|centré]]<br />
<br />
Nous avons choisi de créer un circuit à part pour l'AVR car il ne sera utilisé que pour la programmation et pas pour le fonctionnement de la voiture.[[Fichier:Schématique ISP.png|vignette|Schéma ISP|centré]]<br />
<br />
<br />
== Routage ==<br />
#Carte de la voiture<br />
<br />
<br />
<br />
La carte se connectera directement sur une prise USB pour téléverser le programme dans l'atMega16u2. Les deux faces sont des plans de masse, ce qui facile le routage. Pour faire notre routage, nous avons dû créer certains footprint tels que celui de l'antenne, du moteur continu et du ''BM71BLE01FC2'' (le module bluetooth).[[Fichier:Routage derniere version.png|vignette|Routage|centré]] [[Fichier:Vue 3D carte .png|vignette|Top|centré]] [[Fichier:Vue bottom.png|vignette|Bottom|centré]]<br />
#Carte de l'ISP<br />
<br />
[[Fichier:Routage ISP.png|Routage ISP|centré|sans_cadre]]<br />
<br />
== Carte imprimée ==<br />
Voici la carte imprimée et partiellement soudée (uC, Leds, moteur pas à pas, USB) : <br />
<br />
[[Fichier:Carte imprimée et soudée.png|centré|Carte imprimée|sans_cadre]]<br />
<br />
Avant de souder tous les composants, l'idée était de vérifier si le PC détectait bien la carte, nous avons dû souder un fil sur le Pin 4 et le Pin 5 pour pouvoir alimenter l'ATMega16u2. <br />
== Carte fonctionnelle ==<br />
Premièrement, afin de vérifier si la carte est fonctionnelle nous n'avons soudé que l'atmega, le quartz et le port usb, pour s'assurer avec la commande "''lsusb"'' que la carte est bien vue par le PC. <br />
[[Fichier:Fonction lsusb.png|600x600px|Fonction lsusb|centré|sans_cadre]]<br />
<br />
On voit ici que l'atmega16u2 est bien détecté. <br />
<br />
Maintenant que l'on sait que notre carte fonctionne, on peut passer à la partie programmation des différents composants de la voiture.<br />
== Programmation ==<br />
<br />
Tout d'abord, nous avons écris notre Makefile comme ceci : <br />
[[Fichier:Makefile .png|centré|Makefile|sans_cadre]]<br />
<br />
Nous avons repris la base du programme que nous avons utilisé en TPI (manette) pour configurer les Leds ainsi que le programme ''io.c'' pour utiliser les fonctions présentes dans celui-ci (''output_toogle(), output_set(), ...''). <br />
<br />
Nous avons également repris les configurations des Pins des entrées/sorties des Leds ainsi que les moteurs , comme ci-dessous. <br />
[[Fichier:Pins entrees sorties.png|centré|Config entree/sortie|sans_cadre]]<br />
Par la suite, afin de faire clignoter les Leds, voici le programme (fonctionnel) que nous avons écrit : <br />
[[Fichier:Programme leds.png|centré|Prog leds|sans_cadre]] <br />
<br />
Pour poursuivre, afin de faire fonctionner le moteur pas à pas, nous avons fait quelques recherches pour la programmation. <br />
Pour ce faire, nous nous sommes aidés du chronogramme de l'activité du moteur bipolaire suivant : <br />
[[Fichier:Chronogramme des pas .png|centré|chrono des pas |sans_cadre]]<br />
<br />
Le fonctionnement est simple, les 4 pines du moteur sont connecté directement à 4 pattes du microcontrôleur. et il suffit alors de mettre à 1 chacune des sorties selon le chronogramme ci-dessus <br />
<br />
Voici le code final fonctionnel du moteur pas à pas : <br />
[[Fichier:Code moteur pas à pas .png|centré|prog mots|sans_cadre]]<br />
On trouve l'initialisation des sorties en fonction des pin des moteurs, et on a mis à 1 les sorties grâce à PORTx. Bien sûr, on n'a pas oublié de faire le décalage des pas (comme le chronogramme ci-dessus). <br />
<br />
Notre code ci-dessus permet donc de tourner le moteur dans un sens puis dans l'autre. <br />
<br />
Par la suite, l'idée est de faire fonctionner le moteur directement avec les commandes de l'ordinateur. Pour se faire, on a récupéré les programmes faits en TPI Manette. <br />
<br />
Evidemment, nous devons changer quelques informations, telles que le idVendor et le idProduct. <br />
[[Fichier:Lsusb -vvv.png|centré|sans_cadre|lsusb -vvv]]<br />
Enfin, nous avons ajouter une fonction principale dans lib.c afin de controler, grâce aux octets, l'allumage des leds et du moteur : <br />
[[Fichier:Fonction lib.c.png|centré|sans_cadre]]<br />
Dans data[] : on a 2 octets : le premier qui sert à gérer les Leds et le moteur et la 2ème qu'on n'utilisera pas. <br />
<br />
Les 4 bits de poids faibles servent à allumer les Leds (chaque bit commande une led). <br />
<br />
Les 4 bits de poids forts servent à gérer le moteur(1 pour un un sens, 2 pour l'autre sens) <br />
<br />
Dans le fichier Voiture.c, on a repris les lignes de test_leds.c (notre programme de tests) et les avons mis dans la fonction HandlePCReceive() de Voiture.c. <br />
<br />
== Vidéos système ==<br />
Les vidéos étant trop lourdes, voici un lien Drive de nos vidéos : https://drive.google.com/drive/folders/1xb7-hz1aA-z115mloMOLafnvyD3ojA3p?usp=share_link <br />
<br />
== Conclusion ==<br />
A la fin du projet, notre carte est détecté par le PC, et nous sommes en mesure de programmer le microcontrôleur pour commander les leds et le moteur pas a pas. Il est également possible de commander les leds et le moteur via l'USB.<br />
<br />
<br />
La principale difficulté de ce projet à était la réalisation du PCB sur Kicad, ou nous avons appris plusieurs aspects de la conception d'un PCB : <br />
<br />
- créer des footprint, en allant chercher les dimensions dans les datasheets.<br />
<br />
- s'assurer que notre schéma est cohérant, et que chaque composant est correctement câblé, sans quoi la carte final n'a aucune chance de fonctionner.<br />
<br />
- rooter de manière cohérant, en prenant en compte les perturbations que chaque composants engendre sur les autres, notamment au niveau de l'antenne.<br />
Ce projet nous a aussi permit d'apprendre a souder des composants monté en surface (led, microcontrôleur, résistance).</div>Skaderis