https://projets-se.plil.fr/mediawiki/api.php?action=feedcontributions&feedformat=atom&user=Adjadjaaprojets-se.plil.fr - Contributions [fr]2026-04-17T00:42:31ZContributionsMediaWiki 1.39.1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7385SE4Binome2024-52025-01-26T16:37:57Z<p>Adjadjaa : /* Explications générales sur la réalisation de la carte */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu. (voir l'ajout de selectProcess dans l'ISR)<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
=== Communication série et SPI ===<br />
A l'aide du cours de Mr.Redon et de ressources sur internet nous avons pu confectionner deux librairies, une pour la communication SPI et une pour série (dans le répertoire Ordonnanceur/OldLibs car elle seront remplacées par celles données par Mr.Redon plus tard). Nous pouvons allons faire deux tâche distinctes dans notre ordonnanceur, une pour la communication série qui va récupérer le caractère d'une touche pressée pour l'écrire dans une variable globale tandis que la tâche SPI va lire cette variable globale est l'affiché sur un afficheur 7 segments.<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void serial(void){<br />
while(1){<br />
data = USART_Receive();<br />
USART_sendChar(data);<br />
makeSleep(20);<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void aff7segments(void){<br />
while(1){<br />
aff_activer();<br />
aff_echange(data);<br />
aff_desactiver();<br />
makeSleep(1000);<br />
effacer_affichage();<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
[[Fichier:B5_serie_spi.mp4|vignette|alt=série et spi avec ordonnancement |série et spi avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en cascade pour réduire significativement le nombre de broches nécessaires. Cette solution permet de minimiser l'utilisation des broches du microcontrôleur.<br />
<br />
Nous avons opté pour le décodeur 74HC138D (qui va envoyer un 0 parmi des 1) et trois encodeurs CD4532BM (qui cherche le premier 1 parmi des 0). On sent quand même les problèmes venir petit à petit. Nous avons étudié la datasheet et comment la mise en cascade fonctionne.<br />
[[Fichier:Cascade.png|vignette|alt=Mise en cascade des encodeurs.|Mise en cascade des encodeurs.]]<br />
On voit qu'un encodeur possède un bus de sortie de 5 bits. GS -> à l'état haut quand le composant reçoit un 1, 0 sinon. E0 -> à l'état haut quand il reçoit seulement des 0, 1 sinon. Puis Q2, Q1 ,Q0 la représentation binaire de l'entrée donnée.<br />
<br />
Afin de les mettre en cascade, il faut relié le E0 d'un premier encodeur au Ei de l'autre. Ensuite, nous allons faire un "OU" entre les GS afin de savoir si un des encodeurs reçoit un 1, puis grâce aux GS des deux premiers encodeurs nous sauront quelle encodeur à reçu le 1 (si les deux sont & 0 alors c'est le troisième). De même, faire une porte "OU" sur Q2, Q1, Q0 afin de réduire le nombre d'entrées/sorties nécessaires. <br />
<br />
<p style="clear: both;" /> <br />
<br />
Par ailleurs, étant donné que nous utilisons directement le clavier Dell, il a été nécessaire de concevoir la carte avec des dimensions strictement identiques à celles de la carte d’origine, notamment en ce qui concerne sa largeur. Nous avons également dû ajouter des trous aux emplacements précis pour permettre de visser correctement la carte. Nous avons également dû créer l'empreinte KiCad du connecteur de la matrice, car celle-ci n’était pas disponible dans les bibliothèques existantes.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Empreinte du connecteur matrice]. Pour les connecteurs HE-10 et AVR-ISP, nous avons veillé à les positionner sur la face opposée au connecteur de la matrice. Cela permet de les rendre directement accessibles une fois tous les composants branchés, facilitant ainsi les connexions et les manipulations.<br />
<br />
<br />
<br />
<p style="clear: both;" /><br />
[[Fichier:Clavier dell.png||thumb|right|800px|Clavier DELL]]<br />
<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|left|500px|Carte du clavier DELL]]<br />
<br />
[[Fichier:Matrice clavier dell.png||thumb|right|800px|Matrice du clavier DELL]]<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur 3->8: envoie un 0 parmi des 1.<br />
<br />
<u>CD4532BM</u><br />
* Encodeur 8->3<br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en cascade des encodeurs.<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
===Différents Problèmes rencontrés===<br />
Avant même la réception de la carte, alors que nous commençons a essayé d'écrire un premier programme, nous nous rendions compte qu'envoyer un 0 parmi des 1 et de rechercher un 1 parmi des 0 ne fonctionnera pas (logique). Nous avons alors pris la décision de changer le décodeur car il était pour nous plus simple de changer un composant que les trois encodeurs. Nous avons opté pour lui de la même famille, le 74HTC238D.<br />
<br />
Dès la réception de la carte, nous avons effectué un premier test avec une simple programmation de LED. Nous nous sommes rapidement aperçus que nous avions configuré deux noms d'étiquettes de reset distinctes sur KiCad : une pour l'AVR (RST) et une pour le connecteur HE-10 (RESET). Cependant, seul le reset du connecteur HE-10 était correctement relié au microcontrôleur. Pour résoudre ce problème, nous avons simplement connecté les deux broches de reset à l'aide d'un fil.<br />
<br />
Lors de l'examen initial de notre carte, nous avons également constaté une erreur que nous avions commise. En effet, comme nous avions initialement conçu une matrice de touches sans encodeurs ni décodeurs, il n'était donc pas nécessaire d'intégrer des résistances de pull-up ou de pull-down. Nous avons alors juste rajouter ces composants, or il en résulte que lorsqu'une touche sera pressée, un 1 sera bien envoyé mais pas parmi des 0, parmi des états indéterminé. En général, les états indéterminés, on aime pas trop, surtout quand cela empêche ta carte de pouvoir fonctionner comme voulu. Il a donc été nécessaire d'ajouter des résistances de pull-down sur chaque colonne de notre clavier. Afin de simplifier cette modification, nous avons utilisé des résistances CMS que nous avons positionnées comme des dominos (verticalement), ce qui nous a permis de faire passer un fil de masse directement au-dessus des résistances.<br />
<br />
[[Fichier:Resistance pull Up domino.jpg|center|500px|vignette|Résistances de Pull-down sur les colonnes]]<br />
<br style="clear: both;" /><br />
<br />
Une fois tous ces problèmes de base résolus, nous avons enfin pu nous attaquer à la programmation du clavier. Pour vérifier que toutes les touches étaient correctement détectées, nous avons réalisé un petit programme de test ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]). Ce programme nous a permis d’associer chaque LED à un décodeur différent via la broche GS des décodeurs. Ainsi, nous avons pu identifier quelles touches ne répondaient pas. Premièrement, beaucoup de touches ne répondaient pas, moins d'une dizaine. Nous avons alors fait de multiples tests au multimètre sur notre carte mais aussi sur une autre matrice de touches similaire. Une des hypothèses fut qu'il fallait bien étamer les pistes pour permettre la conduction entre la carte et la matrice. Nous avons alors rajouter de l'étain, puis + de touches commençaient à fonctionner. Il fallait alors un nouveau programme de test pour détecter quelles lignes ou colonnes n'étaient pas bien étamés afin de permettre une conduction ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code de détection]). Il suffisait ainsi de rajouter de l'étain sur les colonnes et les lignes qui ne répondaient pas. Enfin, toutes les touches sont détectées lors de d'une pression !<br />
<br />
==Programmation de la carte==<br />
===Programme de test===<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]<br />
<br />
Lorsqu'une touche est pressée, le contact mécanique rebondit, générant plusieurs signaux rapides. Pour éviter que ces rebonds ne soient interprétés comme plusieurs pressions, nous avons simplement ajouté un délai de 100 millisecondes dans notre programme, ce qui permet d’ignorer ces variations et de ne retenir qu’un signal stable.<br />
<br />
Afin de tester chaque touche de notre matrice, nous avons décidé de faire le programme le plus simple possible en utilisant les broches GS de nos encodeurs. Il n'y a pas d'histoire de ligne ou de colonnes ici, si une touche est pressée alors le GS de l'encodeur ou sa colonne est reliée passera à l'état haut. Une manière très simple de savoir si une touche est utilisable et si nos trois encodeurs sont opérationnels également. Nous avons trois leds pour trois encodeurs, pour chaque encodeur, s'allumera une led spécifique si il reçoit un 1 parmi des 0.<br />
<br />
Afin de mettre en place ce système, il nous faut un programme capable de balayer toutes les lignes de notre matrice via un décodeur.<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
int tab_outputs[8][3] = {<br />
{0, 0, 0},<br />
{1, 0, 0},<br />
{0, 1, 0},<br />
{1, 1, 0},<br />
{0, 0, 1},<br />
{1, 0, 1},<br />
{0, 1, 1},<br />
{1, 1, 1},<br />
};<br />
<br />
<br />
void maj_output(int lig){<br />
for (int i = 0 ; i < 3 ; i++){<br />
if (tab_outputs[lig][i] == 0){<br />
PORTC &= ~(1 << i);<br />
}<br />
else if (tab_outputs[lig][i] == 1){<br />
PORTC |= (1 << i);<br />
}<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<br />
[[Fichier:B5_test_matrice.mp4|vignette|alt=test d'une touche pressée |test d'une touche pressée|right|800px]]<br />
<br style="clear: both;" /><br />
Ici, grâce à l'initialisation d'un tableau de la représentation en binaire des chiffres 0 à 7, il suffit de faire une procédure qui prend en paramètre le numéro de ligne souhaitée puis de vérifier dans le tableau quelle sortie mettre à 0 et 1. Nous avions remarqué que mettre les sorties pour les décodeurs sur le même port côte à côte facilite la programmation.<br />
<br />
===Programme de détection===<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code du test]<br />
<br />
Dans le projet, nous avons eu des problèmes de lignes et colonnes qui n'était pas conduit entre notre carte et la matrice. Pour les identifier, nous avons mis en place un programme de détection qui lors de la pression d'une touche, va afficher grâce aux leds, de quel encodeur sa colonne régit puis quelle ligne et quelle colonne est activée. Ce programme permet ainsi de diagnostiquer rapidement les problèmes de conduction entre la carte et la matrice en identifiant précisément les correspondances défectueuses. <br />
<br />
Pour cela, nous avons imaginer deux fonctions show_ligne et show_colonne, permettant d'afficher sur nos trois leds la ligne et la colonne. Si les leds affichent : double clignotements de la led du milieu (allumée, éteint, allumé) puis (éteint, allumée, allumée) alors la ligne L6 (voir KiCad) et la 4e colonne du deuxième encodeur sont activées.<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_ligne(int i){<br />
turn_off_leds();<br />
for (int bit = 0; bit < 3; bit++){<br />
if (tab_outputs[i][bit] == 1) {<br />
PORTC |= (1 << (bit+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (bit+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_colonne(){<br />
turn_off_leds();<br />
for (int i = Q0; i < Q2 + 1 ; i++){<br />
if (((inputs >> i) & 1) == 1) {<br />
PORTC |= (1 << (i+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (i+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Les deux fonctions se ressemblent beaucoup, la différence étant que show_ligne va prendre un paramètre un entier selon la ligne que nous voulons afficher alors que colonne va directement regarde dans le bus d'entrées la représentation binaire de la colonne activée. A noter que le fait que les LEDs et Q2, Q1, Q0 sont successivement placés sur le même port rend la programmation plus simple à réaliser.<br />
<br />
A noter la présence d'un 'uint8_t inputs;' où l'on va assigner PIND à chaque début d'une boucle, en effet pendant l'afficher l'utilisateur ne reste pas forcément la touche enfoncées ce qui changera les valeurs du bus d'entrée. Il est alors important de sauvegarder l'état de ce bus avant de l'afficher.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_detect.mp4|vignette|alt=test de la détection d'une touche |test de la détection d'une touche|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Ping pong===<br />
<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/PingPongSPI Code du test]<br />
<br />
A l'aide des ressources envoyées par Mr.Redon, nous avons de quoi communiquer entre le shield et notre carte fille. Pour cela, nous avons du modifié un tout petit peu les programmes. En effet, nous avons ajouter un #define pour le Chip Select de notre clavier (le bon connecteur HE10 sur lequel nous allons le connecter) afin que ce soit bien lui qui sera sélectionné lors du spi_select et spi_deselect. Le shield va envoyer un 1 en SPI pour indiquer au clavier qu'il est sur écoute et qu'il attend un envoie de la carte fille.<br />
<br />
Cette communication va nous permettre de bien mapper toutes nos touches.<br />
<br />
Nous avons décidé de faire un tableau en 3 dimensions afin de faciliter le mapping. Pourquoi 3 dimensions ? Nous avons une première dimension pour le numéro de ligne (0 à 7), pour le numéro de colonne (0 à 7) puis pour le numéro d'encodeur (0 à 2). Le bus d'entrée nous donnant un numéro de ligne entre 0 et 7, nous avons trouvé plus facile de procéder de cette manière. Voici un exemple.<br />
<br />
<div style="float:center; width: 48%;"><syntaxhighlight lang="c" line="1"><br />
char tab_touches[8][8][3] = {<br />
{{'\0'/*AltGr*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'-', ' ', '\0'}, {'\0'/*Fleche gauche*/, 'b', '\0'}, {'\0'/*Fleche droite*/, '\0', '\0'}, {'\0'/*Fleche bas*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '!', '\0'}}, <br />
{{'\0', 'x', 'w'}, {'\0', 'c', '\0'/*CTRL Droit*/}, {'*', '\n', '\0'}, {'\0'/*Pause*/, 'v', '\0'}, {'/', ',', '\0'}, {'\0'/*Verr Num*/, ';', '\0'}, {'\0'/*Touch window droite*/, ':', '\0'}, {'\0'/*Shift droit*/, '*', '\0'}}, <br />
{{'\0'/*Arret*/, 'z', 'a'}, {'\0'/*Options*/, 'e', '\0'}, {'9', '\0', '\0'}, {'\0', 'r', '\0'}, {'8', 'u', '\0'}, {'7', 'i', '\0'}, {'\0', 'o', '\0'}, {'*', 'p', '\0'}}, <br />
{{'\0', 's', 'q'}, {'\0'/*Touche window gauche*/, 'd', '\0'}, {'3', '\0', '\0'}, {'\n', 'f', '\0'}, {'2', 'j', '\0'}, {'1', 'k', '\0'}, {'\0', 'l', '\0'}, {'\0', 'm', '\0'}}, <br />
{{'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', 'w'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}}, <br />
{{'\0', '<', '\0'}, {'\0', '\0', '\0'}, {'.', '\0', '\0'}, {'\0', 'g', '\0'}, {'0', 'h', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '%', '\0'}}, <br />
{{'\0', '\0'/*MAJ*/, '\0'/*tab*/}, {'\0', '\0'/*F3*/, '\0'}, {'\0', 8, '\0'}, {'\0', 't', '\0'}, {'5', 'y', '\0'}, {'4', '$', '\0'}, {'\0', '\0'/*F7*/, '\0'}, {'\0'/*Shift gauche*/, '^', '\0'}}, <br />
{{'\0', '\0'/*F1*/, '\0'/*œ*/}, {'\0', '\0'/*F2*/, '\0'/*CTRL Gauche*/}, {'\0'/*Page haut*/, '\0'/*F9*/, '\0'}, {'\0'/*Debut*/, '(', '\0'}, {'\0'/*Insert*/, '-', '\0'}, {'\0'/*Supp*/, '=', '\0'}, {'t', '\n'/*F8*/, '\0'}, {'g', ')', '\0'}}<br />
};<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
<br />
Notre clavier ne supporte pas l'appuie de plusieurs touches en simultané à cause de la présence de décodeurs et d'encodeurs, le shift devient inutilisable, seulement maj est opérationnel. Afin de permettre l'utilisation de altgr, il fonctionnera comme le maj mais les deux ne pourront pas être activés en même temps.<br />
<br />
Nous avons tout d'abord mit des valeurs au hasard mais unique dans le tableau, puis nous avons identifié les touches pour une case dans le tableau, nous avons fait ce processus plusieurs fois afin de trouver toutes les cases des touches du clavier dans le tableau. Pour permettre l'utilisation du maj et du altgr, nous avons créer deux autres tableau comme ça, un chacun avec ses touches assignées. Lors de l'envoie, il faut vérifier dans quel mode nous nous trouvons pour envoyer le caractère dans le bon tableau (alt, maj ou classique).<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
while(1)<br />
{<br />
spi_select();<br />
uint8_t r=spi_exch(1);<br />
if (r != 1) printf("%c",r);<br />
spi_deselect();<br />
_delay_ms(20);<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void envoyer(){<br />
printf("Clavier attente\n");<br />
uint8_t message=spi_wait();<br />
printf("Clavier reçu %d\n",message);<br />
if (message == 1)<br />
spi_sendback(temp);<br />
printf("Clavier retour préparé %d\n",temp);<br />
<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Ici le shield (à gauche) va envoyer un 1 en SPI pour dire au clavier qu'il est prêt à l'écouter, si il reçoit autre chose qu'un 1 (son propre envoie) alors il l'affiche. Le clavier (à droite) va envoyer son dernier caractère dont la touche a été pressée lorsqu'il reçoit ce fameux 1.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_pingpong.mp4|vignette|alt=test clavier sur shield (sans démonstration de altgr et maj) |test clavier sur shield (sans démonstration de altgr et maj)|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Implémentation dans l'ordonnanceur===<br />
Pour pouvoir utiliser le clavier avec l'ordonnanceur, il suffit de faire de notre while(1) précédent, une tâche a part entière de notre ordonnanceur. Sur cet exemple on voit l'utilisation du alt et du maj.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_final.mp4|vignette|alt=test clavier avec ordonnancement |test clavier avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7382SE4Binome2024-52025-01-26T16:31:40Z<p>Adjadjaa : /* Programme de détection */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu. (voir l'ajout de selectProcess dans l'ISR)<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
=== Communication série et SPI ===<br />
A l'aide du cours de Mr.Redon et de ressources sur internet nous avons pu confectionner deux librairies, une pour la communication SPI et une pour série (dans le répertoire Ordonnanceur/OldLibs car elle seront remplacées par celles données par Mr.Redon plus tard). Nous pouvons allons faire deux tâche distinctes dans notre ordonnanceur, une pour la communication série qui va récupérer le caractère d'une touche pressée pour l'écrire dans une variable globale tandis que la tâche SPI va lire cette variable globale est l'affiché sur un afficheur 7 segments.<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void serial(void){<br />
while(1){<br />
data = USART_Receive();<br />
USART_sendChar(data);<br />
makeSleep(20);<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void aff7segments(void){<br />
while(1){<br />
aff_activer();<br />
aff_echange(data);<br />
aff_desactiver();<br />
makeSleep(1000);<br />
effacer_affichage();<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
[[Fichier:B5_serie_spi.mp4|vignette|alt=série et spi avec ordonnancement |série et spi avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en cascade pour réduire significativement le nombre de broches nécessaires. Cette solution permet de minimiser l'utilisation des broches du microcontrôleur.<br />
<br />
Nous avons opté pour le décodeur 74HC138D (qui va envoyer un 0 parmi des 1) et trois encodeurs CD4532BM (qui cherche le premier 1 parmi des 0). On sent quand même les problèmes venir petit à petit. Nous avons étudié la datasheet et comment la mise en cascade fonctionne.<br />
[[Fichier:Cascade.png|vignette|alt=Mise en cascade des encodeurs.|Mise en cascade des encodeurs.]]<br />
On voit qu'un encodeur possède un bus de sortie de 5 bits. GS -> à l'état haut quand le composant reçoit un 1, 0 sinon. E0 -> à l'état haut quand il reçoit seulement des 0, 1 sinon. Puis Q2, Q1 ,Q0 la représentation binaire de l'entrée donnée.<br />
<br />
Afin de les mettre en cascade, il faut relié le E0 d'un premier encodeur au Ei de l'autre. Ensuite, nous allons faire un "OU" entre les GS afin de savoir si un des encodeurs reçoit un 1, puis grâce aux GS des deux premiers encodeurs nous sauront quelle encodeur à reçu le 1 (si les deux sont & 0 alors c'est le troisième). De même, faire une porte "OU" sur Q2, Q1, Q0 afin de réduire le nombre d'entrées/sorties nécessaires. <br />
<br />
<p style="clear: both;" /> <br />
<br />
Par ailleurs, étant donné que nous utilisons directement le clavier Dell, il a été nécessaire de concevoir la carte avec des dimensions strictement identiques à celles de la carte d’origine, notamment en ce qui concerne sa largeur. Nous avons également dû ajouter des trous aux emplacements précis pour permettre de visser correctement la carte. Nous avons également dû créer l'empreinte KiCad du connecteur de la matrice, car celle-ci n’était pas disponible dans les bibliothèques existantes.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Empreinte du connecteur matrice]<br />
<br />
<br />
<br />
<p style="clear: both;" /><br />
[[Fichier:Clavier dell.png||thumb|right|800px|Clavier DELL]]<br />
<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|left|500px|Carte du clavier DELL]]<br />
<br />
[[Fichier:Matrice clavier dell.png||thumb|right|800px|Matrice du clavier DELL]]<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur 3->8: envoie un 0 parmi des 1.<br />
<br />
<u>CD4532BM</u><br />
* Encodeur 8->3<br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en cascade des encodeurs.<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
===Différents Problèmes rencontrés===<br />
Avant même la réception de la carte, alors que nous commençons a essayé d'écrire un premier programme, nous nous rendions compte qu'envoyer un 0 parmi des 1 et de rechercher un 1 parmi des 0 ne fonctionnera pas (logique). Nous avons alors pris la décision de changer le décodeur car il était pour nous plus simple de changer un composant que les trois encodeurs. Nous avons opté pour lui de la même famille, le 74HTC238D.<br />
<br />
Dès la réception de la carte, nous avons effectué un premier test avec une simple programmation de LED. Nous nous sommes rapidement aperçus que nous avions configuré deux noms d'étiquettes de reset distinctes sur KiCad : une pour l'AVR (RST) et une pour le connecteur HE-10 (RESET). Cependant, seul le reset du connecteur HE-10 était correctement relié au microcontrôleur. Pour résoudre ce problème, nous avons simplement connecté les deux broches de reset à l'aide d'un fil.<br />
<br />
Lors de l'examen initial de notre carte, nous avons également constaté une erreur que nous avions commise. En effet, comme nous avions initialement conçu une matrice de touches sans encodeurs ni décodeurs, il n'était donc pas nécessaire d'intégrer des résistances de pull-up ou de pull-down. Nous avons alors juste rajouter ces composants, or il en résulte que lorsqu'une touche sera pressée, un 1 sera bien envoyé mais pas parmi des 0, parmi des états indéterminé. En général, les états indéterminés, on aime pas trop, surtout quand cela empêche ta carte de pouvoir fonctionner comme voulu. Il a donc été nécessaire d'ajouter des résistances de pull-down sur chaque colonne de notre clavier. Afin de simplifier cette modification, nous avons utilisé des résistances CMS que nous avons positionnées comme des dominos (verticalement), ce qui nous a permis de faire passer un fil de masse directement au-dessus des résistances.<br />
<br />
[[Fichier:Resistance pull Up domino.jpg|center|500px|vignette|Résistances de Pull-down sur les colonnes]]<br />
<br style="clear: both;" /><br />
<br />
Une fois tous ces problèmes de base résolus, nous avons enfin pu nous attaquer à la programmation du clavier. Pour vérifier que toutes les touches étaient correctement détectées, nous avons réalisé un petit programme de test ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]). Ce programme nous a permis d’associer chaque LED à un décodeur différent via la broche GS des décodeurs. Ainsi, nous avons pu identifier quelles touches ne répondaient pas. Premièrement, beaucoup de touches ne répondaient pas, moins d'une dizaine. Nous avons alors fait de multiples tests au multimètre sur notre carte mais aussi sur une autre matrice de touches similaire. Une des hypothèses fut qu'il fallait bien étamer les pistes pour permettre la conduction entre la carte et la matrice. Nous avons alors rajouter de l'étain, puis + de touches commençaient à fonctionner. Il fallait alors un nouveau programme de test pour détecter quelles lignes ou colonnes n'étaient pas bien étamés afin de permettre une conduction ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code de détection]). Il suffisait ainsi de rajouter de l'étain sur les colonnes et les lignes qui ne répondaient pas. Enfin, toutes les touches sont détectées lors de d'une pression !<br />
<br />
==Programmation de la carte==<br />
===Programme de test===<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]<br />
<br />
Lorsqu'une touche est pressée, le contact mécanique rebondit, générant plusieurs signaux rapides. Pour éviter que ces rebonds ne soient interprétés comme plusieurs pressions, nous avons simplement ajouté un délai de 100 millisecondes dans notre programme, ce qui permet d’ignorer ces variations et de ne retenir qu’un signal stable.<br />
<br />
Afin de tester chaque touche de notre matrice, nous avons décidé de faire le programme le plus simple possible en utilisant les broches GS de nos encodeurs. Il n'y a pas d'histoire de ligne ou de colonnes ici, si une touche est pressée alors le GS de l'encodeur ou sa colonne est reliée passera à l'état haut. Une manière très simple de savoir si une touche est utilisable et si nos trois encodeurs sont opérationnels également. Nous avons trois leds pour trois encodeurs, pour chaque encodeur, s'allumera une led spécifique si il reçoit un 1 parmi des 0.<br />
<br />
Afin de mettre en place ce système, il nous faut un programme capable de balayer toutes les lignes de notre matrice via un décodeur.<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
int tab_outputs[8][3] = {<br />
{0, 0, 0},<br />
{1, 0, 0},<br />
{0, 1, 0},<br />
{1, 1, 0},<br />
{0, 0, 1},<br />
{1, 0, 1},<br />
{0, 1, 1},<br />
{1, 1, 1},<br />
};<br />
<br />
<br />
void maj_output(int lig){<br />
for (int i = 0 ; i < 3 ; i++){<br />
if (tab_outputs[lig][i] == 0){<br />
PORTC &= ~(1 << i);<br />
}<br />
else if (tab_outputs[lig][i] == 1){<br />
PORTC |= (1 << i);<br />
}<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<br />
[[Fichier:B5_test_matrice.mp4|vignette|alt=test d'une touche pressée |test d'une touche pressée|right|800px]]<br />
<br style="clear: both;" /><br />
Ici, grâce à l'initialisation d'un tableau de la représentation en binaire des chiffres 0 à 7, il suffit de faire une procédure qui prend en paramètre le numéro de ligne souhaitée puis de vérifier dans le tableau quelle sortie mettre à 0 et 1. Nous avions remarqué que mettre les sorties pour les décodeurs sur le même port côte à côte facilite la programmation.<br />
<br />
===Programme de détection===<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code du test]<br />
<br />
Dans le projet, nous avons eu des problèmes de lignes et colonnes qui n'était pas conduit entre notre carte et la matrice. Pour les identifier, nous avons mis en place un programme de détection qui lors de la pression d'une touche, va afficher grâce aux leds, de quel encodeur sa colonne régit puis quelle ligne et quelle colonne est activée. Ce programme permet ainsi de diagnostiquer rapidement les problèmes de conduction entre la carte et la matrice en identifiant précisément les correspondances défectueuses. <br />
<br />
Pour cela, nous avons imaginer deux fonctions show_ligne et show_colonne, permettant d'afficher sur nos trois leds la ligne et la colonne. Si les leds affichent : double clignotements de la led du milieu (allumée, éteint, allumé) puis (éteint, allumée, allumée) alors la ligne L6 (voir KiCad) et la 4e colonne du deuxième encodeur sont activées.<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_ligne(int i){<br />
turn_off_leds();<br />
for (int bit = 0; bit < 3; bit++){<br />
if (tab_outputs[i][bit] == 1) {<br />
PORTC |= (1 << (bit+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (bit+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_colonne(){<br />
turn_off_leds();<br />
for (int i = Q0; i < Q2 + 1 ; i++){<br />
if (((inputs >> i) & 1) == 1) {<br />
PORTC |= (1 << (i+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (i+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Les deux fonctions se ressemblent beaucoup, la différence étant que show_ligne va prendre un paramètre un entier selon la ligne que nous voulons afficher alors que colonne va directement regarde dans le bus d'entrées la représentation binaire de la colonne activée. A noter que le fait que les LEDs et Q2, Q1, Q0 sont successivement placés sur le même port rend la programmation plus simple à réaliser.<br />
<br />
A noter la présence d'un 'uint8_t inputs;' où l'on va assigner PIND à chaque début d'une boucle, en effet pendant l'afficher l'utilisateur ne reste pas forcément la touche enfoncées ce qui changera les valeurs du bus d'entrée. Il est alors important de sauvegarder l'état de ce bus avant de l'afficher.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_detect.mp4|vignette|alt=test de la détection d'une touche |test de la détection d'une touche|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Ping pong===<br />
A l'aide des ressources envoyées par Mr.Redon, nous avons de quoi communiquer entre le shield et notre carte fille. Pour cela, nous avons du modifié un tout petit peu les programmes. En effet, nous avons ajouter un #define pour le Chip Select de notre clavier (le bon connecteur HE10 sur lequel nous allons le connecter) afin que ce soit bien lui qui sera sélectionné lors du spi_select et spi_deselect. Le shield va envoyer un 1 en SPI pour indiquer au clavier qu'il est sur écoute et qu'il attend un envoie de la carte fille.<br />
<br />
Cette communication va nous permettre de bien mapper toutes nos touches.<br />
<br />
Nous avons décidé de faire un tableau en 3 dimensions afin de faciliter le mapping. Pourquoi 3 dimensions ? Nous avons une première dimension pour le numéro de ligne (0 à 7), pour le numéro de colonne (0 à 7) puis pour le numéro d'encodeur (0 à 2). Le bus d'entrée nous donnant un numéro de ligne entre 0 et 7, nous avons trouvé plus facile de procéder de cette manière. Voici un exemple.<br />
<br />
<div style="float:center; width: 48%;"><syntaxhighlight lang="c" line="1"><br />
char tab_touches[8][8][3] = {<br />
{{'\0'/*AltGr*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'-', ' ', '\0'}, {'\0'/*Fleche gauche*/, 'b', '\0'}, {'\0'/*Fleche droite*/, '\0', '\0'}, {'\0'/*Fleche bas*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '!', '\0'}}, <br />
{{'\0', 'x', 'w'}, {'\0', 'c', '\0'/*CTRL Droit*/}, {'*', '\n', '\0'}, {'\0'/*Pause*/, 'v', '\0'}, {'/', ',', '\0'}, {'\0'/*Verr Num*/, ';', '\0'}, {'\0'/*Touch window droite*/, ':', '\0'}, {'\0'/*Shift droit*/, '*', '\0'}}, <br />
{{'\0'/*Arret*/, 'z', 'a'}, {'\0'/*Options*/, 'e', '\0'}, {'9', '\0', '\0'}, {'\0', 'r', '\0'}, {'8', 'u', '\0'}, {'7', 'i', '\0'}, {'\0', 'o', '\0'}, {'*', 'p', '\0'}}, <br />
{{'\0', 's', 'q'}, {'\0'/*Touche window gauche*/, 'd', '\0'}, {'3', '\0', '\0'}, {'\n', 'f', '\0'}, {'2', 'j', '\0'}, {'1', 'k', '\0'}, {'\0', 'l', '\0'}, {'\0', 'm', '\0'}}, <br />
{{'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', 'w'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}}, <br />
{{'\0', '<', '\0'}, {'\0', '\0', '\0'}, {'.', '\0', '\0'}, {'\0', 'g', '\0'}, {'0', 'h', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '%', '\0'}}, <br />
{{'\0', '\0'/*MAJ*/, '\0'/*tab*/}, {'\0', '\0'/*F3*/, '\0'}, {'\0', 8, '\0'}, {'\0', 't', '\0'}, {'5', 'y', '\0'}, {'4', '$', '\0'}, {'\0', '\0'/*F7*/, '\0'}, {'\0'/*Shift gauche*/, '^', '\0'}}, <br />
{{'\0', '\0'/*F1*/, '\0'/*œ*/}, {'\0', '\0'/*F2*/, '\0'/*CTRL Gauche*/}, {'\0'/*Page haut*/, '\0'/*F9*/, '\0'}, {'\0'/*Debut*/, '(', '\0'}, {'\0'/*Insert*/, '-', '\0'}, {'\0'/*Supp*/, '=', '\0'}, {'t', '\n'/*F8*/, '\0'}, {'g', ')', '\0'}}<br />
};<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
<br />
Notre clavier ne supporte pas l'appuie de plusieurs touches en simultané à cause de la présence de décodeurs et d'encodeurs, le shift devient inutilisable, seulement maj est opérationnel. Afin de permettre l'utilisation de altgr, il fonctionnera comme le maj mais les deux ne pourront pas être activés en même temps.<br />
<br />
Nous avons tout d'abord mit des valeurs au hasard mais unique dans le tableau, puis nous avons identifié les touches pour une case dans le tableau, nous avons fait ce processus plusieurs fois afin de trouver toutes les cases des touches du clavier dans le tableau. Pour permettre l'utilisation du maj et du altgr, nous avons créer deux autres tableau comme ça, un chacun avec ses touches assignées. Lors de l'envoie, il faut vérifier dans quel mode nous nous trouvons pour envoyer le caractère dans le bon tableau (alt, maj ou classique).<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
while(1)<br />
{<br />
spi_select();<br />
uint8_t r=spi_exch(1);<br />
if (r != 1) printf("%c",r);<br />
spi_deselect();<br />
_delay_ms(20);<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void envoyer(){<br />
printf("Clavier attente\n");<br />
uint8_t message=spi_wait();<br />
printf("Clavier reçu %d\n",message);<br />
if (message == 1)<br />
spi_sendback(temp);<br />
printf("Clavier retour préparé %d\n",temp);<br />
<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Ici le shield (à gauche) va envoyer un 1 en SPI pour dire au clavier qu'il est prêt à l'écouter, si il reçoit autre chose qu'un 1 (son propre envoie) alors il l'affiche. Le clavier (à droite) va envoyer son dernier caractère dont la touche a été pressée lorsqu'il reçoit ce fameux 1.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_pingpong.mp4|vignette|alt=test clavier sur shield (sans démonstration de altgr et maj) |test clavier sur shield (sans démonstration de altgr et maj)|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Implémentation dans l'ordonnanceur===<br />
Pour pouvoir utiliser le clavier avec l'ordonnanceur, il suffit de faire de notre while(1) précédent, une tâche a part entière de notre ordonnanceur. Sur cet exemple on voit l'utilisation du alt et du maj.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_final.mp4|vignette|alt=test clavier avec ordonnancement |test clavier avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7381SE4Binome2024-52025-01-26T16:30:04Z<p>Adjadjaa : /* Carte Fille Matrice de touches */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu. (voir l'ajout de selectProcess dans l'ISR)<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
=== Communication série et SPI ===<br />
A l'aide du cours de Mr.Redon et de ressources sur internet nous avons pu confectionner deux librairies, une pour la communication SPI et une pour série (dans le répertoire Ordonnanceur/OldLibs car elle seront remplacées par celles données par Mr.Redon plus tard). Nous pouvons allons faire deux tâche distinctes dans notre ordonnanceur, une pour la communication série qui va récupérer le caractère d'une touche pressée pour l'écrire dans une variable globale tandis que la tâche SPI va lire cette variable globale est l'affiché sur un afficheur 7 segments.<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void serial(void){<br />
while(1){<br />
data = USART_Receive();<br />
USART_sendChar(data);<br />
makeSleep(20);<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void aff7segments(void){<br />
while(1){<br />
aff_activer();<br />
aff_echange(data);<br />
aff_desactiver();<br />
makeSleep(1000);<br />
effacer_affichage();<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
[[Fichier:B5_serie_spi.mp4|vignette|alt=série et spi avec ordonnancement |série et spi avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en cascade pour réduire significativement le nombre de broches nécessaires. Cette solution permet de minimiser l'utilisation des broches du microcontrôleur.<br />
<br />
Nous avons opté pour le décodeur 74HC138D (qui va envoyer un 0 parmi des 1) et trois encodeurs CD4532BM (qui cherche le premier 1 parmi des 0). On sent quand même les problèmes venir petit à petit. Nous avons étudié la datasheet et comment la mise en cascade fonctionne.<br />
[[Fichier:Cascade.png|vignette|alt=Mise en cascade des encodeurs.|Mise en cascade des encodeurs.]]<br />
On voit qu'un encodeur possède un bus de sortie de 5 bits. GS -> à l'état haut quand le composant reçoit un 1, 0 sinon. E0 -> à l'état haut quand il reçoit seulement des 0, 1 sinon. Puis Q2, Q1 ,Q0 la représentation binaire de l'entrée donnée.<br />
<br />
Afin de les mettre en cascade, il faut relié le E0 d'un premier encodeur au Ei de l'autre. Ensuite, nous allons faire un "OU" entre les GS afin de savoir si un des encodeurs reçoit un 1, puis grâce aux GS des deux premiers encodeurs nous sauront quelle encodeur à reçu le 1 (si les deux sont & 0 alors c'est le troisième). De même, faire une porte "OU" sur Q2, Q1, Q0 afin de réduire le nombre d'entrées/sorties nécessaires. <br />
<br />
<p style="clear: both;" /> <br />
<br />
Par ailleurs, étant donné que nous utilisons directement le clavier Dell, il a été nécessaire de concevoir la carte avec des dimensions strictement identiques à celles de la carte d’origine, notamment en ce qui concerne sa largeur. Nous avons également dû ajouter des trous aux emplacements précis pour permettre de visser correctement la carte. Nous avons également dû créer l'empreinte KiCad du connecteur de la matrice, car celle-ci n’était pas disponible dans les bibliothèques existantes.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Empreinte du connecteur matrice]<br />
<br />
<br />
<br />
<p style="clear: both;" /><br />
[[Fichier:Clavier dell.png||thumb|right|800px|Clavier DELL]]<br />
<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|left|500px|Carte du clavier DELL]]<br />
<br />
[[Fichier:Matrice clavier dell.png||thumb|right|800px|Matrice du clavier DELL]]<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur 3->8: envoie un 0 parmi des 1.<br />
<br />
<u>CD4532BM</u><br />
* Encodeur 8->3<br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en cascade des encodeurs.<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
===Différents Problèmes rencontrés===<br />
Avant même la réception de la carte, alors que nous commençons a essayé d'écrire un premier programme, nous nous rendions compte qu'envoyer un 0 parmi des 1 et de rechercher un 1 parmi des 0 ne fonctionnera pas (logique). Nous avons alors pris la décision de changer le décodeur car il était pour nous plus simple de changer un composant que les trois encodeurs. Nous avons opté pour lui de la même famille, le 74HTC238D.<br />
<br />
Dès la réception de la carte, nous avons effectué un premier test avec une simple programmation de LED. Nous nous sommes rapidement aperçus que nous avions configuré deux noms d'étiquettes de reset distinctes sur KiCad : une pour l'AVR (RST) et une pour le connecteur HE-10 (RESET). Cependant, seul le reset du connecteur HE-10 était correctement relié au microcontrôleur. Pour résoudre ce problème, nous avons simplement connecté les deux broches de reset à l'aide d'un fil.<br />
<br />
Lors de l'examen initial de notre carte, nous avons également constaté une erreur que nous avions commise. En effet, comme nous avions initialement conçu une matrice de touches sans encodeurs ni décodeurs, il n'était donc pas nécessaire d'intégrer des résistances de pull-up ou de pull-down. Nous avons alors juste rajouter ces composants, or il en résulte que lorsqu'une touche sera pressée, un 1 sera bien envoyé mais pas parmi des 0, parmi des états indéterminé. En général, les états indéterminés, on aime pas trop, surtout quand cela empêche ta carte de pouvoir fonctionner comme voulu. Il a donc été nécessaire d'ajouter des résistances de pull-down sur chaque colonne de notre clavier. Afin de simplifier cette modification, nous avons utilisé des résistances CMS que nous avons positionnées comme des dominos (verticalement), ce qui nous a permis de faire passer un fil de masse directement au-dessus des résistances.<br />
<br />
[[Fichier:Resistance pull Up domino.jpg|center|500px|vignette|Résistances de Pull-down sur les colonnes]]<br />
<br style="clear: both;" /><br />
<br />
Une fois tous ces problèmes de base résolus, nous avons enfin pu nous attaquer à la programmation du clavier. Pour vérifier que toutes les touches étaient correctement détectées, nous avons réalisé un petit programme de test ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]). Ce programme nous a permis d’associer chaque LED à un décodeur différent via la broche GS des décodeurs. Ainsi, nous avons pu identifier quelles touches ne répondaient pas. Premièrement, beaucoup de touches ne répondaient pas, moins d'une dizaine. Nous avons alors fait de multiples tests au multimètre sur notre carte mais aussi sur une autre matrice de touches similaire. Une des hypothèses fut qu'il fallait bien étamer les pistes pour permettre la conduction entre la carte et la matrice. Nous avons alors rajouter de l'étain, puis + de touches commençaient à fonctionner. Il fallait alors un nouveau programme de test pour détecter quelles lignes ou colonnes n'étaient pas bien étamés afin de permettre une conduction ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code de détection]). Il suffisait ainsi de rajouter de l'étain sur les colonnes et les lignes qui ne répondaient pas. Enfin, toutes les touches sont détectées lors de d'une pression !<br />
<br />
==Programmation de la carte==<br />
===Programme de test===<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]<br />
<br />
Lorsqu'une touche est pressée, le contact mécanique rebondit, générant plusieurs signaux rapides. Pour éviter que ces rebonds ne soient interprétés comme plusieurs pressions, nous avons simplement ajouté un délai de 100 millisecondes dans notre programme, ce qui permet d’ignorer ces variations et de ne retenir qu’un signal stable.<br />
<br />
Afin de tester chaque touche de notre matrice, nous avons décidé de faire le programme le plus simple possible en utilisant les broches GS de nos encodeurs. Il n'y a pas d'histoire de ligne ou de colonnes ici, si une touche est pressée alors le GS de l'encodeur ou sa colonne est reliée passera à l'état haut. Une manière très simple de savoir si une touche est utilisable et si nos trois encodeurs sont opérationnels également. Nous avons trois leds pour trois encodeurs, pour chaque encodeur, s'allumera une led spécifique si il reçoit un 1 parmi des 0.<br />
<br />
Afin de mettre en place ce système, il nous faut un programme capable de balayer toutes les lignes de notre matrice via un décodeur.<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
int tab_outputs[8][3] = {<br />
{0, 0, 0},<br />
{1, 0, 0},<br />
{0, 1, 0},<br />
{1, 1, 0},<br />
{0, 0, 1},<br />
{1, 0, 1},<br />
{0, 1, 1},<br />
{1, 1, 1},<br />
};<br />
<br />
<br />
void maj_output(int lig){<br />
for (int i = 0 ; i < 3 ; i++){<br />
if (tab_outputs[lig][i] == 0){<br />
PORTC &= ~(1 << i);<br />
}<br />
else if (tab_outputs[lig][i] == 1){<br />
PORTC |= (1 << i);<br />
}<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<br />
[[Fichier:B5_test_matrice.mp4|vignette|alt=test d'une touche pressée |test d'une touche pressée|right|800px]]<br />
<br style="clear: both;" /><br />
Ici, grâce à l'initialisation d'un tableau de la représentation en binaire des chiffres 0 à 7, il suffit de faire une procédure qui prend en paramètre le numéro de ligne souhaitée puis de vérifier dans le tableau quelle sortie mettre à 0 et 1. Nous avions remarqué que mettre les sorties pour les décodeurs sur le même port côte à côte facilite la programmation.<br />
<br />
===Programme de détection===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code du test])<br />
<br />
Dans le projet, nous avons eu des problèmes de lignes et colonnes qui n'était pas conduit entre notre carte et la matrice. Pour les identifier, nous avons mis en place un programme de détection qui lors de la pression d'une touche, va afficher grâce aux leds, de quel encodeur sa colonne régit puis quelle ligne et quelle colonne est activée. Ce programme permet ainsi de diagnostiquer rapidement les problèmes de conduction entre la carte et la matrice en identifiant précisément les correspondances défectueuses. <br />
<br />
Pour cela, nous avons imaginer deux fonctions show_ligne et show_colonne, permettant d'afficher sur nos trois leds la ligne et la colonne. Si les leds affichent : double clignotements de la led du milieu (allumée, éteint, allumé) puis (éteint, allumée, allumée) alors la ligne L6 (voir KiCad) et la 4e colonne du deuxième encodeur sont activées.<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_ligne(int i){<br />
turn_off_leds();<br />
for (int bit = 0; bit < 3; bit++){<br />
if (tab_outputs[i][bit] == 1) {<br />
PORTC |= (1 << (bit+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (bit+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_colonne(){<br />
turn_off_leds();<br />
for (int i = Q0; i < Q2 + 1 ; i++){<br />
if (((inputs >> i) & 1) == 1) {<br />
PORTC |= (1 << (i+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (i+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Les deux fonctions se ressemblent beaucoup, la différence étant que show_ligne va prendre un paramètre un entier selon la ligne que nous voulons afficher alors que colonne va directement regarde dans le bus d'entrées la représentation binaire de la colonne activée. A noter que le fait que les LEDs et Q2, Q1, Q0 sont successivement placés sur le même port rend la programmation plus simple à réaliser.<br />
<br />
A noter la présence d'un 'uint8_t inputs;' où l'on va assigner PIND à chaque début d'une boucle, en effet pendant l'afficher l'utilisateur ne reste pas forcément la touche enfoncées ce qui changera les valeurs du bus d'entrée. Il est alors important de sauvegarder l'état de ce bus avant de l'afficher.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_detect.mp4|vignette|alt=test de la détection d'une touche |test de la détection d'une touche|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Ping pong===<br />
A l'aide des ressources envoyées par Mr.Redon, nous avons de quoi communiquer entre le shield et notre carte fille. Pour cela, nous avons du modifié un tout petit peu les programmes. En effet, nous avons ajouter un #define pour le Chip Select de notre clavier (le bon connecteur HE10 sur lequel nous allons le connecter) afin que ce soit bien lui qui sera sélectionné lors du spi_select et spi_deselect. Le shield va envoyer un 1 en SPI pour indiquer au clavier qu'il est sur écoute et qu'il attend un envoie de la carte fille.<br />
<br />
Cette communication va nous permettre de bien mapper toutes nos touches.<br />
<br />
Nous avons décidé de faire un tableau en 3 dimensions afin de faciliter le mapping. Pourquoi 3 dimensions ? Nous avons une première dimension pour le numéro de ligne (0 à 7), pour le numéro de colonne (0 à 7) puis pour le numéro d'encodeur (0 à 2). Le bus d'entrée nous donnant un numéro de ligne entre 0 et 7, nous avons trouvé plus facile de procéder de cette manière. Voici un exemple.<br />
<br />
<div style="float:center; width: 48%;"><syntaxhighlight lang="c" line="1"><br />
char tab_touches[8][8][3] = {<br />
{{'\0'/*AltGr*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'-', ' ', '\0'}, {'\0'/*Fleche gauche*/, 'b', '\0'}, {'\0'/*Fleche droite*/, '\0', '\0'}, {'\0'/*Fleche bas*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '!', '\0'}}, <br />
{{'\0', 'x', 'w'}, {'\0', 'c', '\0'/*CTRL Droit*/}, {'*', '\n', '\0'}, {'\0'/*Pause*/, 'v', '\0'}, {'/', ',', '\0'}, {'\0'/*Verr Num*/, ';', '\0'}, {'\0'/*Touch window droite*/, ':', '\0'}, {'\0'/*Shift droit*/, '*', '\0'}}, <br />
{{'\0'/*Arret*/, 'z', 'a'}, {'\0'/*Options*/, 'e', '\0'}, {'9', '\0', '\0'}, {'\0', 'r', '\0'}, {'8', 'u', '\0'}, {'7', 'i', '\0'}, {'\0', 'o', '\0'}, {'*', 'p', '\0'}}, <br />
{{'\0', 's', 'q'}, {'\0'/*Touche window gauche*/, 'd', '\0'}, {'3', '\0', '\0'}, {'\n', 'f', '\0'}, {'2', 'j', '\0'}, {'1', 'k', '\0'}, {'\0', 'l', '\0'}, {'\0', 'm', '\0'}}, <br />
{{'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', 'w'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}}, <br />
{{'\0', '<', '\0'}, {'\0', '\0', '\0'}, {'.', '\0', '\0'}, {'\0', 'g', '\0'}, {'0', 'h', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '%', '\0'}}, <br />
{{'\0', '\0'/*MAJ*/, '\0'/*tab*/}, {'\0', '\0'/*F3*/, '\0'}, {'\0', 8, '\0'}, {'\0', 't', '\0'}, {'5', 'y', '\0'}, {'4', '$', '\0'}, {'\0', '\0'/*F7*/, '\0'}, {'\0'/*Shift gauche*/, '^', '\0'}}, <br />
{{'\0', '\0'/*F1*/, '\0'/*œ*/}, {'\0', '\0'/*F2*/, '\0'/*CTRL Gauche*/}, {'\0'/*Page haut*/, '\0'/*F9*/, '\0'}, {'\0'/*Debut*/, '(', '\0'}, {'\0'/*Insert*/, '-', '\0'}, {'\0'/*Supp*/, '=', '\0'}, {'t', '\n'/*F8*/, '\0'}, {'g', ')', '\0'}}<br />
};<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
<br />
Notre clavier ne supporte pas l'appuie de plusieurs touches en simultané à cause de la présence de décodeurs et d'encodeurs, le shift devient inutilisable, seulement maj est opérationnel. Afin de permettre l'utilisation de altgr, il fonctionnera comme le maj mais les deux ne pourront pas être activés en même temps.<br />
<br />
Nous avons tout d'abord mit des valeurs au hasard mais unique dans le tableau, puis nous avons identifié les touches pour une case dans le tableau, nous avons fait ce processus plusieurs fois afin de trouver toutes les cases des touches du clavier dans le tableau. Pour permettre l'utilisation du maj et du altgr, nous avons créer deux autres tableau comme ça, un chacun avec ses touches assignées. Lors de l'envoie, il faut vérifier dans quel mode nous nous trouvons pour envoyer le caractère dans le bon tableau (alt, maj ou classique).<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
while(1)<br />
{<br />
spi_select();<br />
uint8_t r=spi_exch(1);<br />
if (r != 1) printf("%c",r);<br />
spi_deselect();<br />
_delay_ms(20);<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void envoyer(){<br />
printf("Clavier attente\n");<br />
uint8_t message=spi_wait();<br />
printf("Clavier reçu %d\n",message);<br />
if (message == 1)<br />
spi_sendback(temp);<br />
printf("Clavier retour préparé %d\n",temp);<br />
<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Ici le shield (à gauche) va envoyer un 1 en SPI pour dire au clavier qu'il est prêt à l'écouter, si il reçoit autre chose qu'un 1 (son propre envoie) alors il l'affiche. Le clavier (à droite) va envoyer son dernier caractère dont la touche a été pressée lorsqu'il reçoit ce fameux 1.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_pingpong.mp4|vignette|alt=test clavier sur shield (sans démonstration de altgr et maj) |test clavier sur shield (sans démonstration de altgr et maj)|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Implémentation dans l'ordonnanceur===<br />
Pour pouvoir utiliser le clavier avec l'ordonnanceur, il suffit de faire de notre while(1) précédent, une tâche a part entière de notre ordonnanceur. Sur cet exemple on voit l'utilisation du alt et du maj.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_final.mp4|vignette|alt=test clavier avec ordonnancement |test clavier avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7379SE4Binome2024-52025-01-26T16:25:33Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu. (voir l'ajout de selectProcess dans l'ISR)<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
=== Communication série et SPI ===<br />
A l'aide du cours de Mr.Redon et de ressources sur internet nous avons pu confectionner deux librairies, une pour la communication SPI et une pour série (dans le répertoire Ordonnanceur/OldLibs car elle seront remplacées par celles données par Mr.Redon plus tard). Nous pouvons allons faire deux tâche distinctes dans notre ordonnanceur, une pour la communication série qui va récupérer le caractère d'une touche pressée pour l'écrire dans une variable globale tandis que la tâche SPI va lire cette variable globale est l'affiché sur un afficheur 7 segments.<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void serial(void){<br />
while(1){<br />
data = USART_Receive();<br />
USART_sendChar(data);<br />
makeSleep(20);<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void aff7segments(void){<br />
while(1){<br />
aff_activer();<br />
aff_echange(data);<br />
aff_desactiver();<br />
makeSleep(1000);<br />
effacer_affichage();<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
[[Fichier:B5_serie_spi.mp4|vignette|alt=test clavier sur shield (sans démonstration de altgr et maj) |test clavier sur shield (sans démonstration de altgr et maj)|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en cascade pour réduire significativement le nombre de broches nécessaires. Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
Nous avons opté pour le décodeur 74HC138D (qui va envoyer un 0 parmi des 1) et trois encodeurs CD4532BM (qui cherche le premier 1 parmi des 0). On sent quand même les problèmes venir petit à petit. Nous avons étudié la datasheet et comment la mise en cascade fonctionne.<br />
[[Fichier:Cascade.png|vignette|alt=Mise en cascade des encodeurs.|Mise en cascade des encodeurs.]]<br />
On voit qu'un encodeur possède un bus de sortie de 5 bits. GS -> à l'état haut quand le composant reçoit un 1, 0 sinon. E0 -> à l'état haut quand il reçoit seulement des 0, 1 sinon. Puis Q2, Q1 ,Q0 la représentation binaire de l'entrée donnée.<br />
<br />
Afin de les mettre en cascade, il faut relié le E0 d'un premier encodeur au Ei de l'autre. Ensuite, nous allons faire un "OU" entre les GS afin de savoir si un des encodeurs reçoit un 1, puis grâce aux GS des deux premiers encodeurs nous sauront quelle encodeur à reçu le 1 (si les deux sont & 0 alors c'est le troisième). De même, faire une porte "OU" sur Q2, Q1, Q0 afin de réduire le nombre d'entrées/sorties nécessaires.<br />
<br />
<p style="clear: both;" /> <br />
<br />
Par ailleurs, étant donné que nous utilisons directement le clavier Dell, il a été nécessaire de concevoir la carte avec des dimensions strictement identiques à celles de la carte d’origine, notamment en ce qui concerne sa largeur. Nous avons également dû ajouter des trous aux emplacements précis pour permettre de visser correctement la carte. Nous avons également dû créer l'empreinte KiCad du connecteur de la matrice, car celle-ci n’était pas disponible dans les bibliothèques existantes.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Empreinte du connecteur matrice]<br />
<br />
<br />
<br />
<p style="clear: both;" /><br />
[[Fichier:Clavier dell.png||thumb|right|800px|Clavier DELL]]<br />
<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|left|500px|Carte du clavier DELL]]<br />
<br />
[[Fichier:Matrice clavier dell.png||thumb|right|800px|Matrice du clavier DELL]]<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur : envoie un 0 parmi des 1.<br />
<br />
<u>CD4532BM</u><br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en cascade des encodeurs.<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
===Différents Problèmes rencontrés===<br />
Avant même la réception de la carte, alors que nous commençons a essayé d'écrire un premier programme, nous nous rendions compte qu'envoyer un 0 parmi des 1 et de rechercher un 1 parmi des 0 ne fonctionnera pas (logique). Nous avons alors pris la décision de changer le décodeur car il était pour nous plus simple de changer un composant que les trois encodeurs. Nous avons opté pour lui de la même famille, le 74HTC238D.<br />
<br />
Dès la réception de la carte, nous avons effectué un premier test avec une simple programmation de LED. Nous nous sommes rapidement aperçus que nous avions configuré deux noms d'étiquettes de reset distinctes sur KiCad : une pour l'AVR (RST) et une pour le connecteur HE-10 (RESET). Cependant, seul le reset du connecteur HE-10 était correctement relié au microcontrôleur. Pour résoudre ce problème, nous avons simplement connecté les deux broches de reset à l'aide d'un fil.<br />
<br />
Lors de l'examen initial de notre carte, nous avons également constaté une erreur que nous avions commise. En effet, comme nous avions initialement conçu une matrice de touches sans encodeurs ni décodeurs, il n'était donc pas nécessaire d'intégrer des résistances de pull-up ou de pull-down. Nous avons alors juste rajouter ces composants, or il en résulte que lorsqu'une touche sera pressée, un 1 sera bien envoyé mais pas parmi des 0, parmi des états indéterminé. En général, les états indéterminés, on aime pas trop, surtout quand cela empêche ta carte de pouvoir fonctionner comme voulu. Il a donc été nécessaire d'ajouter des résistances de pull-down sur chaque colonne de notre clavier. Afin de simplifier cette modification, nous avons utilisé des résistances CMS que nous avons positionnées comme des dominos (verticalement), ce qui nous a permis de faire passer un fil de masse directement au-dessus des résistances.<br />
<br />
[[Fichier:Resistance pull Up domino.jpg|center|500px|vignette|Résistances de Pull-down sur les colonnes]]<br />
<br style="clear: both;" /><br />
<br />
Une fois tous ces problèmes de base résolus, nous avons enfin pu nous attaquer à la programmation du clavier. Pour vérifier que toutes les touches étaient correctement détectées, nous avons réalisé un petit programme de test ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]). Ce programme nous a permis d’associer chaque LED à un décodeur différent via la broche GS des décodeurs. Ainsi, nous avons pu identifier quelles touches ne répondaient pas. Premièrement, beaucoup de touches ne répondaient pas, moins d'une dizaine. Nous avons alors fait de multiples tests au multimètre sur notre carte mais aussi sur une autre matrice de touches similaire. Une des hypothèses fut qu'il fallait bien étamer les pistes pour permettre la conduction entre la carte et la matrice. Nous avons alors rajouter de l'étain, puis + de touches commençaient à fonctionner. Il fallait alors un nouveau programme de test pour détecter quelles lignes ou colonnes n'étaient pas bien étamés afin de permettre une conduction ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code de détection]). Il suffisait ainsi de rajouter de l'étain sur les colonnes et les lignes qui ne répondaient pas. Enfin, toutes les touches sont détectées lors de d'une pression !<br />
<br />
==Programmation de la carte==<br />
===Programme de test===<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]<br />
<br />
Lorsqu'une touche est pressée, le contact mécanique rebondit, générant plusieurs signaux rapides. Pour éviter que ces rebonds ne soient interprétés comme plusieurs pressions, nous avons simplement ajouté un délai de 100 millisecondes dans notre programme, ce qui permet d’ignorer ces variations et de ne retenir qu’un signal stable.<br />
<br />
Afin de tester chaque touche de notre matrice, nous avons décidé de faire le programme le plus simple possible en utilisant les broches GS de nos encodeurs. Il n'y a pas d'histoire de ligne ou de colonnes ici, si une touche est pressée alors le GS de l'encodeur ou sa colonne est reliée passera à l'état haut. Une manière très simple de savoir si une touche est utilisable et si nos trois encodeurs sont opérationnels également. Nous avons trois leds pour trois encodeurs, pour chaque encodeur, s'allumera une led spécifique si il reçoit un 1 parmi des 0.<br />
<br />
Afin de mettre en place ce système, il nous faut un programme capable de balayer toutes les lignes de notre matrice via un décodeur.<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
int tab_outputs[8][3] = {<br />
{0, 0, 0},<br />
{1, 0, 0},<br />
{0, 1, 0},<br />
{1, 1, 0},<br />
{0, 0, 1},<br />
{1, 0, 1},<br />
{0, 1, 1},<br />
{1, 1, 1},<br />
};<br />
<br />
<br />
void maj_output(int lig){<br />
for (int i = 0 ; i < 3 ; i++){<br />
if (tab_outputs[lig][i] == 0){<br />
PORTC &= ~(1 << i);<br />
}<br />
else if (tab_outputs[lig][i] == 1){<br />
PORTC |= (1 << i);<br />
}<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<br />
[[Fichier:B5_test_matrice.mp4|vignette|alt=test d'une touche pressée |test d'une touche pressée|right|800px]]<br />
<br style="clear: both;" /><br />
Ici, grâce à l'initialisation d'un tableau de la représentation en binaire des chiffres 0 à 7, il suffit de faire une procédure qui prend en paramètre le numéro de ligne souhaitée puis de vérifier dans le tableau quelle sortie mettre à 0 et 1. Nous avions remarqué que mettre les sorties pour les décodeurs sur le même port côte à côte facilite la programmation.<br />
<br />
===Programme de détection===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code du test])<br />
<br />
Dans le projet, nous avons eu des problèmes de lignes et colonnes qui n'était pas conduit entre notre carte et la matrice. Pour les identifier, nous avons mis en place un programme de détection qui lors de la pression d'une touche, va afficher grâce aux leds, de quel encodeur sa colonne régit puis quelle ligne et quelle colonne est activée. Ce programme permet ainsi de diagnostiquer rapidement les problèmes de conduction entre la carte et la matrice en identifiant précisément les correspondances défectueuses. <br />
<br />
Pour cela, nous avons imaginer deux fonctions show_ligne et show_colonne, permettant d'afficher sur nos trois leds la ligne et la colonne. Si les leds affichent : double clignotements de la led du milieu (allumée, éteint, allumé) puis (éteint, allumée, allumée) alors la ligne L6 (voir KiCad) et la 4e colonne du deuxième encodeur sont activées.<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_ligne(int i){<br />
turn_off_leds();<br />
for (int bit = 0; bit < 3; bit++){<br />
if (tab_outputs[i][bit] == 1) {<br />
PORTC |= (1 << (bit+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (bit+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_colonne(){<br />
turn_off_leds();<br />
for (int i = Q0; i < Q2 + 1 ; i++){<br />
if (((inputs >> i) & 1) == 1) {<br />
PORTC |= (1 << (i+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (i+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Les deux fonctions se ressemblent beaucoup, la différence étant que show_ligne va prendre un paramètre un entier selon la ligne que nous voulons afficher alors que colonne va directement regarde dans le bus d'entrées la représentation binaire de la colonne activée. A noter que le fait que les LEDs et Q2, Q1, Q0 sont successivement placés sur le même port rend la programmation plus simple à réaliser.<br />
<br />
A noter la présence d'un 'uint8_t inputs;' où l'on va assigner PIND à chaque début d'une boucle, en effet pendant l'afficher l'utilisateur ne reste pas forcément la touche enfoncées ce qui changera les valeurs du bus d'entrée. Il est alors important de sauvegarder l'état de ce bus avant de l'afficher.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_detect.mp4|vignette|alt=test de la détection d'une touche |test de la détection d'une touche|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Ping pong===<br />
A l'aide des ressources envoyées par Mr.Redon, nous avons de quoi communiquer entre le shield et notre carte fille. Pour cela, nous avons du modifié un tout petit peu les programmes. En effet, nous avons ajouter un #define pour le Chip Select de notre clavier (le bon connecteur HE10 sur lequel nous allons le connecter) afin que ce soit bien lui qui sera sélectionné lors du spi_select et spi_deselect. Le shield va envoyer un 1 en SPI pour indiquer au clavier qu'il est sur écoute et qu'il attend un envoie de la carte fille.<br />
<br />
Cette communication va nous permettre de bien mapper toutes nos touches.<br />
<br />
Nous avons décidé de faire un tableau en 3 dimensions afin de faciliter le mapping. Pourquoi 3 dimensions ? Nous avons une première dimension pour le numéro de ligne (0 à 7), pour le numéro de colonne (0 à 7) puis pour le numéro d'encodeur (0 à 2). Le bus d'entrée nous donnant un numéro de ligne entre 0 et 7, nous avons trouvé plus facile de procéder de cette manière. Voici un exemple.<br />
<br />
<div style="float:center; width: 48%;"><syntaxhighlight lang="c" line="1"><br />
char tab_touches[8][8][3] = {<br />
{{'\0'/*AltGr*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'-', ' ', '\0'}, {'\0'/*Fleche gauche*/, 'b', '\0'}, {'\0'/*Fleche droite*/, '\0', '\0'}, {'\0'/*Fleche bas*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '!', '\0'}}, <br />
{{'\0', 'x', 'w'}, {'\0', 'c', '\0'/*CTRL Droit*/}, {'*', '\n', '\0'}, {'\0'/*Pause*/, 'v', '\0'}, {'/', ',', '\0'}, {'\0'/*Verr Num*/, ';', '\0'}, {'\0'/*Touch window droite*/, ':', '\0'}, {'\0'/*Shift droit*/, '*', '\0'}}, <br />
{{'\0'/*Arret*/, 'z', 'a'}, {'\0'/*Options*/, 'e', '\0'}, {'9', '\0', '\0'}, {'\0', 'r', '\0'}, {'8', 'u', '\0'}, {'7', 'i', '\0'}, {'\0', 'o', '\0'}, {'*', 'p', '\0'}}, <br />
{{'\0', 's', 'q'}, {'\0'/*Touche window gauche*/, 'd', '\0'}, {'3', '\0', '\0'}, {'\n', 'f', '\0'}, {'2', 'j', '\0'}, {'1', 'k', '\0'}, {'\0', 'l', '\0'}, {'\0', 'm', '\0'}}, <br />
{{'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', 'w'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}}, <br />
{{'\0', '<', '\0'}, {'\0', '\0', '\0'}, {'.', '\0', '\0'}, {'\0', 'g', '\0'}, {'0', 'h', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '%', '\0'}}, <br />
{{'\0', '\0'/*MAJ*/, '\0'/*tab*/}, {'\0', '\0'/*F3*/, '\0'}, {'\0', 8, '\0'}, {'\0', 't', '\0'}, {'5', 'y', '\0'}, {'4', '$', '\0'}, {'\0', '\0'/*F7*/, '\0'}, {'\0'/*Shift gauche*/, '^', '\0'}}, <br />
{{'\0', '\0'/*F1*/, '\0'/*œ*/}, {'\0', '\0'/*F2*/, '\0'/*CTRL Gauche*/}, {'\0'/*Page haut*/, '\0'/*F9*/, '\0'}, {'\0'/*Debut*/, '(', '\0'}, {'\0'/*Insert*/, '-', '\0'}, {'\0'/*Supp*/, '=', '\0'}, {'t', '\n'/*F8*/, '\0'}, {'g', ')', '\0'}}<br />
};<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
<br />
Notre clavier ne supporte pas l'appuie de plusieurs touches en simultané à cause de la présence de décodeurs et d'encodeurs, le shift devient inutilisable, seulement maj est opérationnel. Afin de permettre l'utilisation de altgr, il fonctionnera comme le maj mais les deux ne pourront pas être activés en même temps.<br />
<br />
Nous avons tout d'abord mit des valeurs au hasard mais unique dans le tableau, puis nous avons identifié les touches pour une case dans le tableau, nous avons fait ce processus plusieurs fois afin de trouver toutes les cases des touches du clavier dans le tableau. Pour permettre l'utilisation du maj et du altgr, nous avons créer deux autres tableau comme ça, un chacun avec ses touches assignées. Lors de l'envoie, il faut vérifier dans quel mode nous nous trouvons pour envoyer le caractère dans le bon tableau (alt, maj ou classique).<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
while(1)<br />
{<br />
spi_select();<br />
uint8_t r=spi_exch(1);<br />
if (r != 1) printf("%c",r);<br />
spi_deselect();<br />
_delay_ms(20);<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void envoyer(){<br />
printf("Clavier attente\n");<br />
uint8_t message=spi_wait();<br />
printf("Clavier reçu %d\n",message);<br />
if (message == 1)<br />
spi_sendback(temp);<br />
printf("Clavier retour préparé %d\n",temp);<br />
<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Ici le shield (à gauche) va envoyer un 1 en SPI pour dire au clavier qu'il est prêt à l'écouter, si il reçoit autre chose qu'un 1 (son propre envoie) alors il l'affiche. Le clavier (à droite) va envoyer son dernier caractère dont la touche a été pressée lorsqu'il reçoit ce fameux 1.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_pingpong.mp4|vignette|alt=test clavier sur shield (sans démonstration de altgr et maj) |test clavier sur shield (sans démonstration de altgr et maj)|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Implémentation dans l'ordonnanceur===<br />
Pour pouvoir utiliser le clavier avec l'ordonnanceur, il suffit de faire de notre while(1) précédent, une tâche a part entière de notre ordonnanceur. Sur cet exemple on voit l'utilisation du alt et du maj.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_final.mp4|vignette|alt=test clavier avec ordonnancement |test clavier avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7373SE4Binome2024-52025-01-26T16:17:29Z<p>Adjadjaa : /* Explications générales sur la réalisation de la carte */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu. (voir l'ajout de selectProcess dans l'ISR)<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en cascade pour réduire significativement le nombre de broches nécessaires. Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
Nous avons opté pour le décodeur 74HC138D (qui va envoyer un 0 parmi des 1) et trois encodeurs CD4532BM (qui cherche le premier 1 parmi des 0). On sent quand même les problèmes venir petit à petit. <br />
<br />
Par ailleurs, étant donné que nous utilisons directement le clavier Dell, il a été nécessaire de concevoir la carte avec des dimensions strictement identiques à celles de la carte d’origine, notamment en ce qui concerne sa largeur. Nous avons également dû ajouter des trous aux emplacements précis pour permettre de visser correctement la carte. Nous avons également dû créer l'empreinte KiCad du connecteur de la matrice, car celle-ci n’était pas disponible dans les bibliothèques existantes.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Empreinte du connecteur matrice]<br />
<br />
<br />
<br />
<p style="clear: both;" /><br />
[[Fichier:Clavier dell.png||thumb|right|800px|Clavier DELL]]<br />
<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|left|500px|Carte du clavier DELL]]<br />
<br />
[[Fichier:Matrice clavier dell.png||thumb|right|800px|Matrice du clavier DELL]]<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur : envoie un 0 parmi des 1.<br />
<br />
<u>CD4532BM</u><br />
* Encodeur : Nous avons étudié la datasheet et comment la mise en cascade fonctionne.<br />
[[Fichier:Cascade.png|vignette|alt=Mise en cascade des encodeurs.|Mise en cascade des encodeurs.]]<br />
On voit qu'un encodeur possède un bus de sortie de 5 bits. GS -> à l'état haut quand le composant reçoit un 1, 0 sinon. E0 -> à l'état haut quand il reçoit seulement des 0, 1 sinon. Puis Q2, Q1 ,Q0 la représentation binaire de l'entrée donnée.<br />
<br />
Afin de les mettre en cascade, il faut relié le E0 d'un premier encodeur au Ei de l'autre. Ensuite, nous allons faire un "OU" entre les GS afin de savoir si un des encodeurs reçoit un 1, puis grâce aux GS des deux premiers encodeurs nous sauront quelle encodeur à reçu le 1 (si les deux sont & 0 alors c'est le troisième). De même, faire une porte "OU" sur Q2, Q1, Q0 afin de réduire le nombre d'entrées/sorties nécessaires.<br />
<br />
<p style="clear: both;" /><br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en cascade des encodeurs.<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
====Carte après soudure des composants====<br />
<br />
===Différents Problèmes rencontrés===<br />
Avant même la réception de la carte, alors que nous commençons a essayé d'écrire un premier programme, nous nous rendions compte qu'envoyer un 0 parmi des 1 et de rechercher un 1 parmi des 0 ne fonctionnera pas (logique). Nous avons alors pris la décision de changer le décodeur car il était pour nous plus simple de changer un composant que les trois encodeurs. Nous avons opté pour lui de la même famille, le 74HTC238D.<br />
<br />
Dès la réception de la carte, nous avons effectué un premier test avec une simple programmation de LED. Nous nous sommes rapidement aperçus que nous avions configuré deux noms d'étiquettes de reset distinctes sur KiCad : une pour l'AVR (RST) et une pour le connecteur HE-10 (RESET). Cependant, seul le reset du connecteur HE-10 était correctement relié au microcontrôleur. Pour résoudre ce problème, nous avons simplement connecté les deux broches de reset à l'aide d'un fil.<br />
<br />
Lors de l'examen initial de notre carte, nous avons également constaté une erreur que nous avions commise. En effet, comme nous avions initialement conçu une matrice de touches sans encodeurs ni décodeurs, il n'était donc pas nécessaire d'intégrer des résistances de pull-up ou de pull-down. Nous avons alors juste rajouter ces composants, or il en résulte que lorsqu'une touche sera pressée, un 1 sera bien envoyé mais pas parmi des 0, parmi des états indéterminé. En général, les états indéterminés, on aime pas trop, surtout quand cela empêche ta carte de pouvoir fonctionner comme voulu. Il a donc été nécessaire d'ajouter des résistances de pull-down sur chaque colonne de notre clavier. Afin de simplifier cette modification, nous avons utilisé des résistances CMS que nous avons positionnées comme des dominos (verticalement), ce qui nous a permis de faire passer un fil de masse directement au-dessus des résistances.<br />
<br />
[[Fichier:Resistance pull Up domino.jpg|center|500px|vignette|Résistances de Pull-down sur les colonnes]]<br />
<br style="clear: both;" /><br />
<br />
Une fois tous ces problèmes de base résolus, nous avons enfin pu nous attaquer à la programmation du clavier. Pour vérifier que toutes les touches étaient correctement détectées, nous avons réalisé un petit programme de test ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]). Ce programme nous a permis d’associer chaque LED à un décodeur différent via la broche GS des décodeurs. Ainsi, nous avons pu identifier quelles touches ne répondaient pas. Premièrement, beaucoup de touches ne répondaient pas, moins d'une dizaine. Nous avons alors fait de multiples tests au multimètre sur notre carte mais aussi sur une autre matrice de touches similaire. Une des hypothèses fut qu'il fallait bien étamer les pistes pour permettre la conduction entre la carte et la matrice. Nous avons alors rajouter de l'étain, puis + de touches commençaient à fonctionner. Il fallait alors un nouveau programme de test pour détecter quelles lignes ou colonnes n'étaient pas bien étamés afin de permettre une conduction ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code de détection]). Il suffisait ainsi de rajouter de l'étain sur les colonnes et les lignes qui ne répondaient pas. Enfin, toutes les touches sont détectées lors de d'une pression !<br />
<br />
==Programmation de la carte==<br />
===Programme de test===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test])<br />
<br />
Afin de tester chaque touche de notre matrice, nous avons décidé de faire le programme le plus simple possible en utilisant les broches GS de nos encodeurs. Il n'y a pas d'histoire de ligne ou de colonnes ici, si une touche est pressée alors le GS de l'encodeur ou sa colonne est reliée passera à l'état haut. Une manière très simple de savoir si une touche est utilisable et si nos trois encodeurs sont opérationnels également. Nous avons trois leds pour trois encodeurs, pour chaque encodeur, s'allumera une led spécifique si il reçoit un 1 parmi des 0.<br />
<br />
Afin de mettre en place ce système, il nous faut un programme capable de balayer toutes les lignes de notre matrice via un décodeur.<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
int tab_outputs[8][3] = {<br />
{0, 0, 0},<br />
{1, 0, 0},<br />
{0, 1, 0},<br />
{1, 1, 0},<br />
{0, 0, 1},<br />
{1, 0, 1},<br />
{0, 1, 1},<br />
{1, 1, 1},<br />
};<br />
<br />
<br />
void maj_output(int lig){<br />
for (int i = 0 ; i < 3 ; i++){<br />
if (tab_outputs[lig][i] == 0){<br />
PORTC &= ~(1 << i);<br />
}<br />
else if (tab_outputs[lig][i] == 1){<br />
PORTC |= (1 << i);<br />
}<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<br />
[[Fichier:B5_test_matrice.mp4|vignette|alt=test d'une touche pressée |test d'une touche pressée|right|800px]]<br />
<br style="clear: both;" /><br />
Ici, grâce à l'initialisation d'un tableau de la représentation en binaire des chiffres 0 à 7, il suffit de faire une procédure qui prend en paramètre le numéro de ligne souhaitée puis de vérifier dans le tableau quelle sortie mettre à 0 et 1. Nous avions remarqué que mettre les sorties pour les décodeurs sur le même port côte à côte facilite la programmation.<br />
<br />
===Programme de détection===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code du test])<br />
<br />
Dans le projet, nous avons eu des problèmes de lignes et colonnes qui n'était pas conduit entre notre carte et la matrice. Pour les identifier, nous avons mis en place un programme de détection qui lors de la pression d'une touche, va afficher grâce aux leds, de quel encodeur sa colonne régit puis quelle ligne et quelle colonne est activée. Ce programme permet ainsi de diagnostiquer rapidement les problèmes de conduction entre la carte et la matrice en identifiant précisément les correspondances défectueuses. <br />
<br />
Pour cela, nous avons imaginer deux fonctions show_ligne et show_colonne, permettant d'afficher sur nos trois leds la ligne et la colonne. Si les leds affichent : double clignotements de la led du milieu (allumée, éteint, allumé) puis (éteint, allumée, allumée) alors la ligne L6 (voir KiCad) et la 4e colonne du deuxième encodeur sont activées.<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_ligne(int i){<br />
turn_off_leds();<br />
for (int bit = 0; bit < 3; bit++){<br />
if (tab_outputs[i][bit] == 1) {<br />
PORTC |= (1 << (bit+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (bit+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_colonne(){<br />
turn_off_leds();<br />
for (int i = Q0; i < Q2 + 1 ; i++){<br />
if (((inputs >> i) & 1) == 1) {<br />
PORTC |= (1 << (i+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (i+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Les deux fonctions se ressemblent beaucoup, la différence étant que show_ligne va prendre un paramètre un entier selon la ligne que nous voulons afficher alors que colonne va directement regarde dans le bus d'entrées la représentation binaire de la colonne activée. A noter que le fait que les LEDs et Q2, Q1, Q0 sont successivement placés sur le même port rend la programmation plus simple à réaliser.<br />
<br />
A noter la présence d'un 'uint8_t inputs;' où l'on va assigner PIND à chaque début d'une boucle, en effet pendant l'afficher l'utilisateur ne reste pas forcément la touche enfoncées ce qui changera les valeurs du bus d'entrée. Il est alors important de sauvegarder l'état de ce bus avant de l'afficher.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_detect.mp4|vignette|alt=test de la détection d'une touche |test de la détection d'une touche|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Ping pong===<br />
A l'aide des ressources envoyées par Mr.Redon, nous avons de quoi communiquer entre le shield et notre carte fille. Pour cela, nous avons du modifié un tout petit peu les programmes. En effet, nous avons ajouter un #define pour le Chip Select de notre clavier (le bon connecteur HE10 sur lequel nous allons le connecter) afin que ce soit bien lui qui sera sélectionné lors du spi_select et spi_deselect. Le shield va envoyer un 1 en SPI pour indiquer au clavier qu'il est sur écoute et qu'il attend un envoie de la carte fille.<br />
<br />
Cette communication va nous permettre de bien mapper toutes nos touches.<br />
<br />
Nous avons décidé de faire un tableau en 3 dimensions afin de faciliter le mapping. Pourquoi 3 dimensions ? Nous avons une première dimension pour le numéro de ligne (0 à 7), pour le numéro de colonne (0 à 7) puis pour le numéro d'encodeur (0 à 2). Le bus d'entrée nous donnant un numéro de ligne entre 0 et 7, nous avons trouvé plus facile de procéder de cette manière. Voici un exemple.<br />
<br />
<div style="float:center; width: 48%;"><syntaxhighlight lang="c" line="1"><br />
char tab_touches[8][8][3] = {<br />
{{'\0'/*AltGr*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'-', ' ', '\0'}, {'\0'/*Fleche gauche*/, 'b', '\0'}, {'\0'/*Fleche droite*/, '\0', '\0'}, {'\0'/*Fleche bas*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '!', '\0'}}, <br />
{{'\0', 'x', 'w'}, {'\0', 'c', '\0'/*CTRL Droit*/}, {'*', '\n', '\0'}, {'\0'/*Pause*/, 'v', '\0'}, {'/', ',', '\0'}, {'\0'/*Verr Num*/, ';', '\0'}, {'\0'/*Touch window droite*/, ':', '\0'}, {'\0'/*Shift droit*/, '*', '\0'}}, <br />
{{'\0'/*Arret*/, 'z', 'a'}, {'\0'/*Options*/, 'e', '\0'}, {'9', '\0', '\0'}, {'\0', 'r', '\0'}, {'8', 'u', '\0'}, {'7', 'i', '\0'}, {'\0', 'o', '\0'}, {'*', 'p', '\0'}}, <br />
{{'\0', 's', 'q'}, {'\0'/*Touche window gauche*/, 'd', '\0'}, {'3', '\0', '\0'}, {'\n', 'f', '\0'}, {'2', 'j', '\0'}, {'1', 'k', '\0'}, {'\0', 'l', '\0'}, {'\0', 'm', '\0'}}, <br />
{{'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', 'w'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}}, <br />
{{'\0', '<', '\0'}, {'\0', '\0', '\0'}, {'.', '\0', '\0'}, {'\0', 'g', '\0'}, {'0', 'h', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '%', '\0'}}, <br />
{{'\0', '\0'/*MAJ*/, '\0'/*tab*/}, {'\0', '\0'/*F3*/, '\0'}, {'\0', 8, '\0'}, {'\0', 't', '\0'}, {'5', 'y', '\0'}, {'4', '$', '\0'}, {'\0', '\0'/*F7*/, '\0'}, {'\0'/*Shift gauche*/, '^', '\0'}}, <br />
{{'\0', '\0'/*F1*/, '\0'/*œ*/}, {'\0', '\0'/*F2*/, '\0'/*CTRL Gauche*/}, {'\0'/*Page haut*/, '\0'/*F9*/, '\0'}, {'\0'/*Debut*/, '(', '\0'}, {'\0'/*Insert*/, '-', '\0'}, {'\0'/*Supp*/, '=', '\0'}, {'t', '\n'/*F8*/, '\0'}, {'g', ')', '\0'}}<br />
};<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
<br />
Notre clavier ne supporte pas l'appuie de plusieurs touches en simultané à cause de la présence de décodeurs et d'encodeurs, le shift devient inutilisable, seulement maj est opérationnel. Afin de permettre l'utilisation de altgr, il fonctionnera comme le maj mais les deux ne pourront pas être activés en même temps.<br />
<br />
Nous avons tout d'abord mit des valeurs au hasard mais unique dans le tableau, puis nous avons identifié les touches pour une case dans le tableau, nous avons fait ce processus plusieurs fois afin de trouver toutes les cases des touches du clavier dans le tableau. Pour permettre l'utilisation du maj et du altgr, nous avons créer deux autres tableau comme ça, un chacun avec ses touches assignées. Lors de l'envoie, il faut vérifier dans quel mode nous nous trouvons pour envoyer le caractère dans le bon tableau (alt, maj ou classique).<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
while(1)<br />
{<br />
spi_select();<br />
uint8_t r=spi_exch(1);<br />
if (r != 1) printf("%c",r);<br />
spi_deselect();<br />
_delay_ms(20);<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void envoyer(){<br />
printf("Clavier attente\n");<br />
uint8_t message=spi_wait();<br />
printf("Clavier reçu %d\n",message);<br />
if (message == 1)<br />
spi_sendback(temp);<br />
printf("Clavier retour préparé %d\n",temp);<br />
<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Ici le shield (à gauche) va envoyer un 1 en SPI pour dire au clavier qu'il est prêt à l'écouter, si il reçoit autre chose qu'un 1 (son propre envoie) alors il l'affiche. Le clavier (à droite) va envoyer son dernier caractère dont la touche a été pressée lorsqu'il reçoit ce fameux 1.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_pingpong.mp4|vignette|alt=test clavier sur shield (sans démonstration de altgr et maj) |test clavier sur shield (sans démonstration de altgr et maj)|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Implémentation dans l'ordonnanceur===<br />
Pour pouvoir utiliser le clavier avec l'ordonnanceur, il suffit de faire de notre while(1) précédent, une tâche a part entière de notre ordonnanceur. Sur cet exemple on voit l'utilisation du alt et du maj.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_final.mp4|vignette|alt=test clavier avec ordonnancement |test clavier avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7364SE4Binome2024-52025-01-26T16:11:01Z<p>Adjadjaa : /* Explications générales sur la réalisation de la carte */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu. (voir l'ajout de selectProcess dans l'ISR)<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en cascade pour réduire significativement le nombre de broches nécessaires. Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
Nous avons opté pour le décodeur 74HC138D (qui va envoyer un 0 parmi des 1) et trois encodeurs CD4532BM (qui cherche le premier 1 parmi des 0). On sent quand même les problèmes venir petit à petit.<br />
<br />
Par ailleurs, étant donné que nous utilisons directement le clavier Dell, il a été nécessaire de concevoir la carte avec des dimensions strictement identiques à celles de la carte d’origine, notamment en ce qui concerne sa largeur. Nous avons également dû ajouter des trous aux emplacements précis pour permettre de visser correctement la carte. Nous avons également dû créer l'empreinte KiCad du connecteur de la matrice, car celle-ci n’était pas disponible dans les bibliothèques existantes.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Empreinte du connecteur matrice]<br />
<br />
<br />
<br />
<p style="clear: both;" /><br />
[[Fichier:Clavier dell.png||thumb|right|800px|Clavier DELL]]<br />
<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|left|500px|Carte du clavier DELL]]<br />
<br />
[[Fichier:Matrice clavier dell.png||thumb|right|800px|Matrice du clavier DELL]]<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur : envoie un 0 parmi des 1.<br />
<br />
<u>CD4532BM</u><br />
* Encodeur : Nous avons étudié la datasheet et comment la mise en cascade fonctionne.<br />
[[Fichier:Cascade.png|vignette|alt=Mise en cascade des encodeurs.|Mise en cascade des encodeurs.]]<br />
On voit qu'un encodeur possède un bus de sortie de 5 bits. GS -> à l'état haut quand le composant reçoit un 1, 0 sinon. E0 -> à l'état haut quand il reçoit seulement des 0, 1 sinon. Puis Q2, Q1 ,Q0 la représentation binaire de l'entrée donnée.<br />
<br />
Afin de les mettre en cascade, il faut relié le E0 d'un premier encodeur au Ei de l'autre. Ensuite, nous allons faire un "OU" entre les GS afin de savoir si un des encodeurs reçoit un 1, puis grâce aux GS des deux premiers encodeurs nous sauront quelle encodeur à reçu le 1 (si les deux sont & 0 alors c'est le troisième). De même, faire une porte "OU" sur Q2, Q1, Q0 afin de réduire le nombre d'entrées/sorties nécessaires.<br />
<br />
<p style="clear: both;" /><br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en cascade des encodeurs.<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
====Carte après soudure des composants====<br />
<br />
===Différents Problèmes rencontrés===<br />
Avant même la réception de la carte, alors que nous commençons a essayé d'écrire un premier programme, nous nous rendions compte qu'envoyer un 0 parmi des 1 et de rechercher un 1 parmi des 0 ne fonctionnera pas (logique). Nous avons alors pris la décision de changer le décodeur car il était pour nous plus simple de changer un composant que les trois encodeurs. Nous avons opté pour lui de la même famille, le 74HTC238D.<br />
<br />
Dès la réception de la carte, nous avons effectué un premier test avec une simple programmation de LED. Nous nous sommes rapidement aperçus que nous avions configuré deux noms d'étiquettes de reset distinctes sur KiCad : une pour l'AVR (RST) et une pour le connecteur HE-10 (RESET). Cependant, seul le reset du connecteur HE-10 était correctement relié au microcontrôleur. Pour résoudre ce problème, nous avons simplement connecté les deux broches de reset à l'aide d'un fil.<br />
<br />
Lors de l'examen initial de notre carte, nous avons également constaté une erreur que nous avions commise. En effet, comme nous avions initialement conçu une matrice de touches sans encodeurs ni décodeurs, il n'était donc pas nécessaire d'intégrer des résistances de pull-up ou de pull-down. Nous avons alors juste rajouter ces composants, or il en résulte que lorsqu'une touche sera pressée, un 1 sera bien envoyé mais pas parmi des 0, parmi des états indéterminé. En général, les états indéterminés, on aime pas trop, surtout quand cela empêche ta carte de pouvoir fonctionner comme voulu. Il a donc été nécessaire d'ajouter des résistances de pull-down sur chaque colonne de notre clavier. Afin de simplifier cette modification, nous avons utilisé des résistances CMS que nous avons positionnées comme des dominos (verticalement), ce qui nous a permis de faire passer un fil de masse directement au-dessus des résistances.<br />
<br />
[[Fichier:Resistance pull Up domino.jpg|center|500px|vignette|Résistances de Pull-down sur les colonnes]]<br />
<br style="clear: both;" /><br />
<br />
Une fois tous ces problèmes de base résolus, nous avons enfin pu nous attaquer à la programmation du clavier. Pour vérifier que toutes les touches étaient correctement détectées, nous avons réalisé un petit programme de test ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]). Ce programme nous a permis d’associer chaque LED à un décodeur différent via la broche GS des décodeurs. Ainsi, nous avons pu identifier quelles touches ne répondaient pas. Premièrement, beaucoup de touches ne répondaient pas, moins d'une dizaine. Nous avons alors fait de multiples tests au multimètre sur notre carte mais aussi sur une autre matrice de touches similaire. Une des hypothèses fut qu'il fallait bien étamer les pistes pour permettre la conduction entre la carte et la matrice. Nous avons alors rajouter de l'étain, puis + de touches commençaient à fonctionner. Il fallait alors un nouveau programme de test pour détecter quelles lignes ou colonnes n'étaient pas bien étamés afin de permettre une conduction ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code de détection]). Il suffisait ainsi de rajouter de l'étain sur les colonnes et les lignes qui ne répondaient pas. Enfin, toutes les touches sont détectées lors de d'une pression !<br />
<br />
==Programmation de la carte==<br />
===Programme de test===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test])<br />
<br />
Afin de tester chaque touche de notre matrice, nous avons décidé de faire le programme le plus simple possible en utilisant les broches GS de nos encodeurs. Il n'y a pas d'histoire de ligne ou de colonnes ici, si une touche est pressée alors le GS de l'encodeur ou sa colonne est reliée passera à l'état haut. Une manière très simple de savoir si une touche est utilisable et si nos trois encodeurs sont opérationnels également. Nous avons trois leds pour trois encodeurs, pour chaque encodeur, s'allumera une led spécifique si il reçoit un 1 parmi des 0.<br />
<br />
Afin de mettre en place ce système, il nous faut un programme capable de balayer toutes les lignes de notre matrice via un décodeur.<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
int tab_outputs[8][3] = {<br />
{0, 0, 0},<br />
{1, 0, 0},<br />
{0, 1, 0},<br />
{1, 1, 0},<br />
{0, 0, 1},<br />
{1, 0, 1},<br />
{0, 1, 1},<br />
{1, 1, 1},<br />
};<br />
<br />
<br />
void maj_output(int lig){<br />
for (int i = 0 ; i < 3 ; i++){<br />
if (tab_outputs[lig][i] == 0){<br />
PORTC &= ~(1 << i);<br />
}<br />
else if (tab_outputs[lig][i] == 1){<br />
PORTC |= (1 << i);<br />
}<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<br />
[[Fichier:B5_test_matrice.mp4|vignette|alt=test d'une touche pressée |test d'une touche pressée|right|800px]]<br />
<br style="clear: both;" /><br />
Ici, grâce à l'initialisation d'un tableau de la représentation en binaire des chiffres 0 à 7, il suffit de faire une procédure qui prend en paramètre le numéro de ligne souhaitée puis de vérifier dans le tableau quelle sortie mettre à 0 et 1. Nous avions remarqué que mettre les sorties pour les décodeurs sur le même port côte à côte facilite la programmation.<br />
<br />
===Programme de détection===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code du test])<br />
<br />
Dans le projet, nous avons eu des problèmes de lignes et colonnes qui n'était pas conduit entre notre carte et la matrice. Pour les identifier, nous avons mis en place un programme de détection qui lors de la pression d'une touche, va afficher grâce aux leds, de quel encodeur sa colonne régit puis quelle ligne et quelle colonne est activée. Ce programme permet ainsi de diagnostiquer rapidement les problèmes de conduction entre la carte et la matrice en identifiant précisément les correspondances défectueuses. <br />
<br />
Pour cela, nous avons imaginer deux fonctions show_ligne et show_colonne, permettant d'afficher sur nos trois leds la ligne et la colonne. Si les leds affichent : double clignotements de la led du milieu (allumée, éteint, allumé) puis (éteint, allumée, allumée) alors la ligne L6 (voir KiCad) et la 4e colonne du deuxième encodeur sont activées.<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_ligne(int i){<br />
turn_off_leds();<br />
for (int bit = 0; bit < 3; bit++){<br />
if (tab_outputs[i][bit] == 1) {<br />
PORTC |= (1 << (bit+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (bit+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_colonne(){<br />
turn_off_leds();<br />
for (int i = Q0; i < Q2 + 1 ; i++){<br />
if (((inputs >> i) & 1) == 1) {<br />
PORTC |= (1 << (i+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (i+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Les deux fonctions se ressemblent beaucoup, la différence étant que show_ligne va prendre un paramètre un entier selon la ligne que nous voulons afficher alors que colonne va directement regarde dans le bus d'entrées la représentation binaire de la colonne activée. A noter que le fait que les LEDs et Q2, Q1, Q0 sont successivement placés sur le même port rend la programmation plus simple à réaliser.<br />
<br />
A noter la présence d'un 'uint8_t inputs;' où l'on va assigner PIND à chaque début d'une boucle, en effet pendant l'afficher l'utilisateur ne reste pas forcément la touche enfoncées ce qui changera les valeurs du bus d'entrée. Il est alors important de sauvegarder l'état de ce bus avant de l'afficher.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_detect.mp4|vignette|alt=test de la détection d'une touche |test de la détection d'une touche|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Ping pong===<br />
A l'aide des ressources envoyées par Mr.Redon, nous avons de quoi communiquer entre le shield et notre carte fille. Pour cela, nous avons du modifié un tout petit peu les programmes. En effet, nous avons ajouter un #define pour le Chip Select de notre clavier (le bon connecteur HE10 sur lequel nous allons le connecter) afin que ce soit bien lui qui sera sélectionné lors du spi_select et spi_deselect. Le shield va envoyer un 1 en SPI pour indiquer au clavier qu'il est sur écoute et qu'il attend un envoie de la carte fille.<br />
<br />
Cette communication va nous permettre de bien mapper toutes nos touches.<br />
<br />
Nous avons décidé de faire un tableau en 3 dimensions afin de faciliter le mapping. Pourquoi 3 dimensions ? Nous avons une première dimension pour le numéro de ligne (0 à 7), pour le numéro de colonne (0 à 7) puis pour le numéro d'encodeur (0 à 2). Le bus d'entrée nous donnant un numéro de ligne entre 0 et 7, nous avons trouvé plus facile de procéder de cette manière. Voici un exemple.<br />
<br />
<div style="float:center; width: 48%;"><syntaxhighlight lang="c" line="1"><br />
char tab_touches[8][8][3] = {<br />
{{'\0'/*AltGr*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'-', ' ', '\0'}, {'\0'/*Fleche gauche*/, 'b', '\0'}, {'\0'/*Fleche droite*/, '\0', '\0'}, {'\0'/*Fleche bas*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '!', '\0'}}, <br />
{{'\0', 'x', 'w'}, {'\0', 'c', '\0'/*CTRL Droit*/}, {'*', '\n', '\0'}, {'\0'/*Pause*/, 'v', '\0'}, {'/', ',', '\0'}, {'\0'/*Verr Num*/, ';', '\0'}, {'\0'/*Touch window droite*/, ':', '\0'}, {'\0'/*Shift droit*/, '*', '\0'}}, <br />
{{'\0'/*Arret*/, 'z', 'a'}, {'\0'/*Options*/, 'e', '\0'}, {'9', '\0', '\0'}, {'\0', 'r', '\0'}, {'8', 'u', '\0'}, {'7', 'i', '\0'}, {'\0', 'o', '\0'}, {'*', 'p', '\0'}}, <br />
{{'\0', 's', 'q'}, {'\0'/*Touche window gauche*/, 'd', '\0'}, {'3', '\0', '\0'}, {'\n', 'f', '\0'}, {'2', 'j', '\0'}, {'1', 'k', '\0'}, {'\0', 'l', '\0'}, {'\0', 'm', '\0'}}, <br />
{{'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', 'w'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}}, <br />
{{'\0', '<', '\0'}, {'\0', '\0', '\0'}, {'.', '\0', '\0'}, {'\0', 'g', '\0'}, {'0', 'h', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '%', '\0'}}, <br />
{{'\0', '\0'/*MAJ*/, '\0'/*tab*/}, {'\0', '\0'/*F3*/, '\0'}, {'\0', 8, '\0'}, {'\0', 't', '\0'}, {'5', 'y', '\0'}, {'4', '$', '\0'}, {'\0', '\0'/*F7*/, '\0'}, {'\0'/*Shift gauche*/, '^', '\0'}}, <br />
{{'\0', '\0'/*F1*/, '\0'/*œ*/}, {'\0', '\0'/*F2*/, '\0'/*CTRL Gauche*/}, {'\0'/*Page haut*/, '\0'/*F9*/, '\0'}, {'\0'/*Debut*/, '(', '\0'}, {'\0'/*Insert*/, '-', '\0'}, {'\0'/*Supp*/, '=', '\0'}, {'t', '\n'/*F8*/, '\0'}, {'g', ')', '\0'}}<br />
};<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
<br />
Notre clavier ne supporte pas l'appuie de plusieurs touches en simultané à cause de la présence de décodeurs et d'encodeurs, le shift devient inutilisable, seulement maj est opérationnel. Afin de permettre l'utilisation de altgr, il fonctionnera comme le maj mais les deux ne pourront pas être activés en même temps.<br />
<br />
Nous avons tout d'abord mit des valeurs au hasard mais unique dans le tableau, puis nous avons identifié les touches pour une case dans le tableau, nous avons fait ce processus plusieurs fois afin de trouver toutes les cases des touches du clavier dans le tableau. Pour permettre l'utilisation du maj et du altgr, nous avons créer deux autres tableau comme ça, un chacun avec ses touches assignées. Lors de l'envoie, il faut vérifier dans quel mode nous nous trouvons pour envoyer le caractère dans le bon tableau (alt, maj ou classique).<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
while(1)<br />
{<br />
spi_select();<br />
uint8_t r=spi_exch(1);<br />
if (r != 1) printf("%c",r);<br />
spi_deselect();<br />
_delay_ms(20);<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void envoyer(){<br />
printf("Clavier attente\n");<br />
uint8_t message=spi_wait();<br />
printf("Clavier reçu %d\n",message);<br />
if (message == 1)<br />
spi_sendback(temp);<br />
printf("Clavier retour préparé %d\n",temp);<br />
<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Ici le shield (à gauche) va envoyer un 1 en SPI pour dire au clavier qu'il est prêt à l'écouter, si il reçoit autre chose qu'un 1 (son propre envoie) alors il l'affiche. Le clavier (à droite) va envoyer son dernier caractère dont la touche a été pressée lorsqu'il reçoit ce fameux 1.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_pingpong.mp4|vignette|alt=test clavier sur shield (sans démonstration de altgr et maj) |test clavier sur shield (sans démonstration de altgr et maj)|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Implémentation dans l'ordonnanceur===<br />
Pour pouvoir utiliser le clavier avec l'ordonnanceur, il suffit de faire de notre while(1) précédent, une tâche a part entière de notre ordonnanceur. Sur cet exemple on voit l'utilisation du alt et du maj.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_final.mp4|vignette|alt=test clavier avec ordonnancement |test clavier avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7360SE4Binome2024-52025-01-26T16:04:22Z<p>Adjadjaa : /* Différents Problèmes rencontrés */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu. (voir l'ajout de selectProcess dans l'ISR)<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en cascade pour réduire significativement le nombre de broches nécessaires. Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
Nous avons opté pour le décodeur 74HC138D (qui va envoyer un 0 parmi des 1) et trois encodeurs CD4532BM (qui cherche le premier 1 parmi des 0). On sent quand même les problèmes venir petit à petit.<br />
<p style="clear: both;" /><br />
[[Fichier:Clavier dell.png||thumb|right|800px|Clavier DELL]]<br />
<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|left|500px|Carte du clavier DELL]]<br />
<br />
[[Fichier:Matrice clavier dell.png||thumb|right|800px|Matrice du clavier DELL]]<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur : envoie un 0 parmi des 1.<br />
<br />
<u>CD4532BM</u><br />
* Encodeur : Nous avons étudié la datasheet et comment la mise en cascade fonctionne.<br />
[[Fichier:Cascade.png|vignette|alt=Mise en cascade des encodeurs.|Mise en cascade des encodeurs.]]<br />
On voit qu'un encodeur possède un bus de sortie de 5 bits. GS -> à l'état haut quand le composant reçoit un 1, 0 sinon. E0 -> à l'état haut quand il reçoit seulement des 0, 1 sinon. Puis Q2, Q1 ,Q0 la représentation binaire de l'entrée donnée.<br />
<br />
Afin de les mettre en cascade, il faut relié le E0 d'un premier encodeur au Ei de l'autre. Ensuite, nous allons faire un "OU" entre les GS afin de savoir si un des encodeurs reçoit un 1, puis grâce aux GS des deux premiers encodeurs nous sauront quelle encodeur à reçu le 1 (si les deux sont & 0 alors c'est le troisième). De même, faire une porte "OU" sur Q2, Q1, Q0 afin de réduire le nombre d'entrées/sorties nécessaires.<br />
<br />
<p style="clear: both;" /><br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en cascade des encodeurs.<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
====Carte après soudure des composants====<br />
<br />
===Différents Problèmes rencontrés===<br />
Avant même la réception de la carte, alors que nous commençons a essayé d'écrire un premier programme, nous nous rendions compte qu'envoyer un 0 parmi des 1 et de rechercher un 1 parmi des 0 ne fonctionnera pas (logique). Nous avons alors pris la décision de changer le décodeur car il était pour nous plus simple de changer un composant que les trois encodeurs. Nous avons opté pour lui de la même famille, le 74HTC238D.<br />
<br />
Dès la réception de la carte, nous avons effectué un premier test avec une simple programmation de LED. Nous nous sommes rapidement aperçus que nous avions configuré deux noms d'étiquettes de reset distinctes sur KiCad : une pour l'AVR (RST) et une pour le connecteur HE-10 (RESET). Cependant, seul le reset du connecteur HE-10 était correctement relié au microcontrôleur. Pour résoudre ce problème, nous avons simplement connecté les deux broches de reset à l'aide d'un fil.<br />
<br />
Lors de l'examen initial de notre carte, nous avons également constaté une erreur que nous avions commise. En effet, comme nous avions initialement conçu une matrice de touches sans encodeurs ni décodeurs, il n'était donc pas nécessaire d'intégrer des résistances de pull-up ou de pull-down. Nous avons alors juste rajouter ces composants, or il en résulte que lorsqu'une touche sera pressée, un 1 sera bien envoyé mais pas parmi des 0, parmi des états indéterminé. En général, les états indéterminés, on aime pas trop, surtout quand cela empêche ta carte de pouvoir fonctionner comme voulu. Il a donc été nécessaire d'ajouter des résistances de pull-down sur chaque colonne de notre clavier. Afin de simplifier cette modification, nous avons utilisé des résistances CMS que nous avons positionnées comme des dominos (verticalement), ce qui nous a permis de faire passer un fil de masse directement au-dessus des résistances.<br />
<br />
[[Fichier:Resistance pull Up domino.jpg|center|500px|vignette|Résistances de Pull-down sur les colonnes]]<br />
<br style="clear: both;" /><br />
<br />
Une fois tous ces problèmes de base résolus, nous avons enfin pu nous attaquer à la programmation du clavier. Pour vérifier que toutes les touches étaient correctement détectées, nous avons réalisé un petit programme de test ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]). Ce programme nous a permis d’associer chaque LED à un décodeur différent via la broche GS des décodeurs. Ainsi, nous avons pu identifier quelles touches ne répondaient pas. Premièrement, beaucoup de touches ne répondaient pas, moins d'une dizaine. Nous avons alors fait de multiples tests au multimètre sur notre carte mais aussi sur une autre matrice de touches similaire. Une des hypothèses fut qu'il fallait bien étamer les pistes pour permettre la conduction entre la carte et la matrice. Nous avons alors rajouter de l'étain, puis + de touches commençaient à fonctionner. Il fallait alors un nouveau programme de test pour détecter quelles lignes ou colonnes n'étaient pas bien étamés afin de permettre une conduction ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code de détection]). Il suffisait ainsi de rajouter de l'étain sur les colonnes et les lignes qui ne répondaient pas. Enfin, toutes les touches sont détectées lors de d'une pression !<br />
<br />
==Programmation de la carte==<br />
===Programme de test===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test])<br />
<br />
Afin de tester chaque touche de notre matrice, nous avons décidé de faire le programme le plus simple possible en utilisant les broches GS de nos encodeurs. Il n'y a pas d'histoire de ligne ou de colonnes ici, si une touche est pressée alors le GS de l'encodeur ou sa colonne est reliée passera à l'état haut. Une manière très simple de savoir si une touche est utilisable et si nos trois encodeurs sont opérationnels également. Nous avons trois leds pour trois encodeurs, pour chaque encodeur, s'allumera une led spécifique si il reçoit un 1 parmi des 0.<br />
<br />
Afin de mettre en place ce système, il nous faut un programme capable de balayer toutes les lignes de notre matrice via un décodeur.<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
int tab_outputs[8][3] = {<br />
{0, 0, 0},<br />
{1, 0, 0},<br />
{0, 1, 0},<br />
{1, 1, 0},<br />
{0, 0, 1},<br />
{1, 0, 1},<br />
{0, 1, 1},<br />
{1, 1, 1},<br />
};<br />
<br />
<br />
void maj_output(int lig){<br />
for (int i = 0 ; i < 3 ; i++){<br />
if (tab_outputs[lig][i] == 0){<br />
PORTC &= ~(1 << i);<br />
}<br />
else if (tab_outputs[lig][i] == 1){<br />
PORTC |= (1 << i);<br />
}<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<br />
[[Fichier:B5_test_matrice.mp4|vignette|alt=test d'une touche pressée |test d'une touche pressée|right|800px]]<br />
<br style="clear: both;" /><br />
Ici, grâce à l'initialisation d'un tableau de la représentation en binaire des chiffres 0 à 7, il suffit de faire une procédure qui prend en paramètre le numéro de ligne souhaitée puis de vérifier dans le tableau quelle sortie mettre à 0 et 1. Nous avions remarqué que mettre les sorties pour les décodeurs sur le même port côte à côte facilite la programmation.<br />
<br />
===Programme de détection===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code du test])<br />
<br />
Dans le projet, nous avons eu des problèmes de lignes et colonnes qui n'était pas conduit entre notre carte et la matrice. Pour les identifier, nous avons mis en place un programme de détection qui lors de la pression d'une touche, va afficher grâce aux leds, de quel encodeur sa colonne régit puis quelle ligne et quelle colonne est activée. Ce programme permet ainsi de diagnostiquer rapidement les problèmes de conduction entre la carte et la matrice en identifiant précisément les correspondances défectueuses. <br />
<br />
Pour cela, nous avons imaginer deux fonctions show_ligne et show_colonne, permettant d'afficher sur nos trois leds la ligne et la colonne. Si les leds affichent : double clignotements de la led du milieu (allumée, éteint, allumé) puis (éteint, allumée, allumée) alors la ligne L6 (voir KiCad) et la 4e colonne du deuxième encodeur sont activées.<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_ligne(int i){<br />
turn_off_leds();<br />
for (int bit = 0; bit < 3; bit++){<br />
if (tab_outputs[i][bit] == 1) {<br />
PORTC |= (1 << (bit+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (bit+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_colonne(){<br />
turn_off_leds();<br />
for (int i = Q0; i < Q2 + 1 ; i++){<br />
if (((inputs >> i) & 1) == 1) {<br />
PORTC |= (1 << (i+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (i+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Les deux fonctions se ressemblent beaucoup, la différence étant que show_ligne va prendre un paramètre un entier selon la ligne que nous voulons afficher alors que colonne va directement regarde dans le bus d'entrées la représentation binaire de la colonne activée. A noter que le fait que les LEDs et Q2, Q1, Q0 sont successivement placés sur le même port rend la programmation plus simple à réaliser.<br />
<br />
A noter la présence d'un 'uint8_t inputs;' où l'on va assigner PIND à chaque début d'une boucle, en effet pendant l'afficher l'utilisateur ne reste pas forcément la touche enfoncées ce qui changera les valeurs du bus d'entrée. Il est alors important de sauvegarder l'état de ce bus avant de l'afficher.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_detect.mp4|vignette|alt=test de la détection d'une touche |test de la détection d'une touche|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Ping pong===<br />
A l'aide des ressources envoyées par Mr.Redon, nous avons de quoi communiquer entre le shield et notre carte fille. Pour cela, nous avons du modifié un tout petit peu les programmes. En effet, nous avons ajouter un #define pour le Chip Select de notre clavier (le bon connecteur HE10 sur lequel nous allons le connecter) afin que ce soit bien lui qui sera sélectionné lors du spi_select et spi_deselect. Le shield va envoyer un 1 en SPI pour indiquer au clavier qu'il est sur écoute et qu'il attend un envoie de la carte fille.<br />
<br />
Cette communication va nous permettre de bien mapper toutes nos touches.<br />
<br />
Nous avons décidé de faire un tableau en 3 dimensions afin de faciliter le mapping. Pourquoi 3 dimensions ? Nous avons une première dimension pour le numéro de ligne (0 à 7), pour le numéro de colonne (0 à 7) puis pour le numéro d'encodeur (0 à 2). Le bus d'entrée nous donnant un numéro de ligne entre 0 et 7, nous avons trouvé plus facile de procéder de cette manière. Voici un exemple.<br />
<br />
<div style="float:center; width: 48%;"><syntaxhighlight lang="c" line="1"><br />
char tab_touches[8][8][3] = {<br />
{{'\0'/*AltGr*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'-', ' ', '\0'}, {'\0'/*Fleche gauche*/, 'b', '\0'}, {'\0'/*Fleche droite*/, '\0', '\0'}, {'\0'/*Fleche bas*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '!', '\0'}}, <br />
{{'\0', 'x', 'w'}, {'\0', 'c', '\0'/*CTRL Droit*/}, {'*', '\n', '\0'}, {'\0'/*Pause*/, 'v', '\0'}, {'/', ',', '\0'}, {'\0'/*Verr Num*/, ';', '\0'}, {'\0'/*Touch window droite*/, ':', '\0'}, {'\0'/*Shift droit*/, '*', '\0'}}, <br />
{{'\0'/*Arret*/, 'z', 'a'}, {'\0'/*Options*/, 'e', '\0'}, {'9', '\0', '\0'}, {'\0', 'r', '\0'}, {'8', 'u', '\0'}, {'7', 'i', '\0'}, {'\0', 'o', '\0'}, {'*', 'p', '\0'}}, <br />
{{'\0', 's', 'q'}, {'\0'/*Touche window gauche*/, 'd', '\0'}, {'3', '\0', '\0'}, {'\n', 'f', '\0'}, {'2', 'j', '\0'}, {'1', 'k', '\0'}, {'\0', 'l', '\0'}, {'\0', 'm', '\0'}}, <br />
{{'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', 'w'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}}, <br />
{{'\0', '<', '\0'}, {'\0', '\0', '\0'}, {'.', '\0', '\0'}, {'\0', 'g', '\0'}, {'0', 'h', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '%', '\0'}}, <br />
{{'\0', '\0'/*MAJ*/, '\0'/*tab*/}, {'\0', '\0'/*F3*/, '\0'}, {'\0', 8, '\0'}, {'\0', 't', '\0'}, {'5', 'y', '\0'}, {'4', '$', '\0'}, {'\0', '\0'/*F7*/, '\0'}, {'\0'/*Shift gauche*/, '^', '\0'}}, <br />
{{'\0', '\0'/*F1*/, '\0'/*œ*/}, {'\0', '\0'/*F2*/, '\0'/*CTRL Gauche*/}, {'\0'/*Page haut*/, '\0'/*F9*/, '\0'}, {'\0'/*Debut*/, '(', '\0'}, {'\0'/*Insert*/, '-', '\0'}, {'\0'/*Supp*/, '=', '\0'}, {'t', '\n'/*F8*/, '\0'}, {'g', ')', '\0'}}<br />
};<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
<br />
Notre clavier ne supporte pas l'appuie de plusieurs touches en simultané à cause de la présence de décodeurs et d'encodeurs, le shift devient inutilisable, seulement maj est opérationnel. Afin de permettre l'utilisation de altgr, il fonctionnera comme le maj mais les deux ne pourront pas être activés en même temps.<br />
<br />
Nous avons tout d'abord mit des valeurs au hasard mais unique dans le tableau, puis nous avons identifié les touches pour une case dans le tableau, nous avons fait ce processus plusieurs fois afin de trouver toutes les cases des touches du clavier dans le tableau. Pour permettre l'utilisation du maj et du altgr, nous avons créer deux autres tableau comme ça, un chacun avec ses touches assignées. Lors de l'envoie, il faut vérifier dans quel mode nous nous trouvons pour envoyer le caractère dans le bon tableau (alt, maj ou classique).<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
while(1)<br />
{<br />
spi_select();<br />
uint8_t r=spi_exch(1);<br />
if (r != 1) printf("%c",r);<br />
spi_deselect();<br />
_delay_ms(20);<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void envoyer(){<br />
printf("Clavier attente\n");<br />
uint8_t message=spi_wait();<br />
printf("Clavier reçu %d\n",message);<br />
if (message == 1)<br />
spi_sendback(temp);<br />
printf("Clavier retour préparé %d\n",temp);<br />
<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Ici le shield (à gauche) va envoyer un 1 en SPI pour dire au clavier qu'il est prêt à l'écouter, si il reçoit autre chose qu'un 1 (son propre envoie) alors il l'affiche. Le clavier (à droite) va envoyer son dernier caractère dont la touche a été pressée lorsqu'il reçoit ce fameux 1.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_pingpong.mp4|vignette|alt=test clavier sur shield (sans démonstration de altgr et maj) |test clavier sur shield (sans démonstration de altgr et maj)|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Implémentation dans l'ordonnanceur===<br />
Pour pouvoir utiliser le clavier avec l'ordonnanceur, il suffit de faire de notre while(1) précédent, une tâche a part entière de notre ordonnanceur. Sur cet exemple on voit l'utilisation du alt et du maj.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_final.mp4|vignette|alt=test clavier avec ordonnancement |test clavier avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7357SE4Binome2024-52025-01-26T16:01:47Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu. (voir l'ajout de selectProcess dans l'ISR)<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en cascade pour réduire significativement le nombre de broches nécessaires. Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
Nous avons opté pour le décodeur 74HC138D (qui va envoyer un 0 parmi des 1) et trois encodeurs CD4532BM (qui cherche le premier 1 parmi des 0). On sent quand même les problèmes venir petit à petit.<br />
<p style="clear: both;" /><br />
[[Fichier:Clavier dell.png||thumb|right|800px|Clavier DELL]]<br />
<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|left|500px|Carte du clavier DELL]]<br />
<br />
[[Fichier:Matrice clavier dell.png||thumb|right|800px|Matrice du clavier DELL]]<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur : envoie un 0 parmi des 1.<br />
<br />
<u>CD4532BM</u><br />
* Encodeur : Nous avons étudié la datasheet et comment la mise en cascade fonctionne.<br />
[[Fichier:Cascade.png|vignette|alt=Mise en cascade des encodeurs.|Mise en cascade des encodeurs.]]<br />
On voit qu'un encodeur possède un bus de sortie de 5 bits. GS -> à l'état haut quand le composant reçoit un 1, 0 sinon. E0 -> à l'état haut quand il reçoit seulement des 0, 1 sinon. Puis Q2, Q1 ,Q0 la représentation binaire de l'entrée donnée.<br />
<br />
Afin de les mettre en cascade, il faut relié le E0 d'un premier encodeur au Ei de l'autre. Ensuite, nous allons faire un "OU" entre les GS afin de savoir si un des encodeurs reçoit un 1, puis grâce aux GS des deux premiers encodeurs nous sauront quelle encodeur à reçu le 1 (si les deux sont & 0 alors c'est le troisième). De même, faire une porte "OU" sur Q2, Q1, Q0 afin de réduire le nombre d'entrées/sorties nécessaires.<br />
<br />
<p style="clear: both;" /><br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en cascade des encodeurs.<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
====Carte après soudure des composants====<br />
<br />
===Différents Problèmes rencontrés===<br />
Avant même la réception de la carte, alors que nous commençons a essayé d'écrire un premier programme, nous nous rendions compte qu'envoyer un 0 parmi des 1 et de rechercher un 1 parmi des 0 ne fonctionnera pas (logique). Nous avons alors pris la décision de changer le décodeur car il était pour nous plus simple de changer un composant que les trois encodeurs. Nous avons opté pour lui de la même famille, le 74HTC238D.<br />
<br />
Dès la réception de la carte, nous avons effectué un premier test avec une simple programmation de LED. Nous nous sommes rapidement aperçus que nous avions configuré deux noms d'étiquettes de reset distinctes sur KiCad : une pour l'AVR (RST) et une pour le connecteur HE-10 (RESET). Cependant, seul le reset du connecteur HE-10 était correctement relié au microcontrôleur. Pour résoudre ce problème, nous avons simplement connecté les deux broches de reset à l'aide d'un fil.<br />
<br />
Lors de l'examen initial de notre carte, nous avons également constaté une erreur que nous avions commise. En effet, comme nous avions initialement conçu une matrice de touches sans encodeurs ni décodeurs, il n'était donc pas nécessaire d'intégrer des résistances de pull-up ou de pull-down. Nous avons alors juste rajouter ces composants, or il en résulte que lorsqu'une touche sera pressée, un 1 sera bien envoyé mais pas parmi des 0, parmi des états indéterminé. En général, les états indéterminés, on aime pas trop, surtout quand cela empêche ta carte de pouvoir fonctionner comme voulu. Il a donc été nécessaire d'ajouter des résistances de pull-down sur chaque colonne de notre clavier. Afin de simplifier cette modification, nous avons utilisé des résistances CMS que nous avons positionnées comme des dominos (verticalement), ce qui nous a permis de faire passer un fil de masse directement au-dessus des résistances.<br />
<br />
[[Fichier:Resistance pull Up domino.jpg|vignette|Résistances de Pull-down sur les colonnes]]<br />
<br style="clear: both;" /><br />
<br />
Une fois tous ces problèmes de base résolus, nous avons enfin pu nous attaquer à la programmation du clavier. Pour vérifier que toutes les touches étaient correctement détectées, nous avons réalisé un petit programme de test ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]). Ce programme nous a permis d’associer chaque LED à un décodeur différent via la broche GS des décodeurs. Ainsi, nous avons pu identifier quelles touches ne répondaient pas. Premièrement, beaucoup de touches ne répondaient pas, moins d'une dizaine. Nous avons alors fait de multiples tests au multimètre sur notre carte mais aussi sur une autre matrice de touches similaire. Une des hypothèses fut qu'il fallait bien étamer les pistes pour permettre la conduction entre la carte et la matrice. Nous avons alors rajouter de l'étain, puis + de touches commençaient à fonctionner. Il fallait alors un nouveau programme de test pour détecter quelles lignes ou colonnes n'étaient pas bien étamés afin de permettre une conduction ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code de détection]). Il suffisait ainsi de rajouter de l'étain sur les colonnes et les lignes qui ne répondaient pas. Enfin, toutes les touches sont détectées lors de d'une pression !<br />
<br />
==Programmation de la carte==<br />
===Programme de test===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test])<br />
<br />
Afin de tester chaque touche de notre matrice, nous avons décidé de faire le programme le plus simple possible en utilisant les broches GS de nos encodeurs. Il n'y a pas d'histoire de ligne ou de colonnes ici, si une touche est pressée alors le GS de l'encodeur ou sa colonne est reliée passera à l'état haut. Une manière très simple de savoir si une touche est utilisable et si nos trois encodeurs sont opérationnels également. Nous avons trois leds pour trois encodeurs, pour chaque encodeur, s'allumera une led spécifique si il reçoit un 1 parmi des 0.<br />
<br />
Afin de mettre en place ce système, il nous faut un programme capable de balayer toutes les lignes de notre matrice via un décodeur.<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
int tab_outputs[8][3] = {<br />
{0, 0, 0},<br />
{1, 0, 0},<br />
{0, 1, 0},<br />
{1, 1, 0},<br />
{0, 0, 1},<br />
{1, 0, 1},<br />
{0, 1, 1},<br />
{1, 1, 1},<br />
};<br />
<br />
<br />
void maj_output(int lig){<br />
for (int i = 0 ; i < 3 ; i++){<br />
if (tab_outputs[lig][i] == 0){<br />
PORTC &= ~(1 << i);<br />
}<br />
else if (tab_outputs[lig][i] == 1){<br />
PORTC |= (1 << i);<br />
}<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<br />
[[Fichier:B5_test_matrice.mp4|vignette|alt=test d'une touche pressée |test d'une touche pressée|right|800px]]<br />
<br style="clear: both;" /><br />
Ici, grâce à l'initialisation d'un tableau de la représentation en binaire des chiffres 0 à 7, il suffit de faire une procédure qui prend en paramètre le numéro de ligne souhaitée puis de vérifier dans le tableau quelle sortie mettre à 0 et 1. Nous avions remarqué que mettre les sorties pour les décodeurs sur le même port côte à côte facilite la programmation.<br />
<br />
===Programme de détection===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code du test])<br />
<br />
Dans le projet, nous avons eu des problèmes de lignes et colonnes qui n'était pas conduit entre notre carte et la matrice. Pour les identifier, nous avons mis en place un programme de détection qui lors de la pression d'une touche, va afficher grâce aux leds, de quel encodeur sa colonne régit puis quelle ligne et quelle colonne est activée. Ce programme permet ainsi de diagnostiquer rapidement les problèmes de conduction entre la carte et la matrice en identifiant précisément les correspondances défectueuses. <br />
<br />
Pour cela, nous avons imaginer deux fonctions show_ligne et show_colonne, permettant d'afficher sur nos trois leds la ligne et la colonne. Si les leds affichent : double clignotements de la led du milieu (allumée, éteint, allumé) puis (éteint, allumée, allumée) alors la ligne L6 (voir KiCad) et la 4e colonne du deuxième encodeur sont activées.<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_ligne(int i){<br />
turn_off_leds();<br />
for (int bit = 0; bit < 3; bit++){<br />
if (tab_outputs[i][bit] == 1) {<br />
PORTC |= (1 << (bit+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (bit+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_colonne(){<br />
turn_off_leds();<br />
for (int i = Q0; i < Q2 + 1 ; i++){<br />
if (((inputs >> i) & 1) == 1) {<br />
PORTC |= (1 << (i+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (i+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Les deux fonctions se ressemblent beaucoup, la différence étant que show_ligne va prendre un paramètre un entier selon la ligne que nous voulons afficher alors que colonne va directement regarde dans le bus d'entrées la représentation binaire de la colonne activée. A noter que le fait que les LEDs et Q2, Q1, Q0 sont successivement placés sur le même port rend la programmation plus simple à réaliser.<br />
<br />
A noter la présence d'un 'uint8_t inputs;' où l'on va assigner PIND à chaque début d'une boucle, en effet pendant l'afficher l'utilisateur ne reste pas forcément la touche enfoncées ce qui changera les valeurs du bus d'entrée. Il est alors important de sauvegarder l'état de ce bus avant de l'afficher.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_detect.mp4|vignette|alt=test de la détection d'une touche |test de la détection d'une touche|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Ping pong===<br />
A l'aide des ressources envoyées par Mr.Redon, nous avons de quoi communiquer entre le shield et notre carte fille. Pour cela, nous avons du modifié un tout petit peu les programmes. En effet, nous avons ajouter un #define pour le Chip Select de notre clavier (le bon connecteur HE10 sur lequel nous allons le connecter) afin que ce soit bien lui qui sera sélectionné lors du spi_select et spi_deselect. Le shield va envoyer un 1 en SPI pour indiquer au clavier qu'il est sur écoute et qu'il attend un envoie de la carte fille.<br />
<br />
Cette communication va nous permettre de bien mapper toutes nos touches.<br />
<br />
Nous avons décidé de faire un tableau en 3 dimensions afin de faciliter le mapping. Pourquoi 3 dimensions ? Nous avons une première dimension pour le numéro de ligne (0 à 7), pour le numéro de colonne (0 à 7) puis pour le numéro d'encodeur (0 à 2). Le bus d'entrée nous donnant un numéro de ligne entre 0 et 7, nous avons trouvé plus facile de procéder de cette manière. Voici un exemple.<br />
<br />
<div style="float:center; width: 48%;"><syntaxhighlight lang="c" line="1"><br />
char tab_touches[8][8][3] = {<br />
{{'\0'/*AltGr*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'-', ' ', '\0'}, {'\0'/*Fleche gauche*/, 'b', '\0'}, {'\0'/*Fleche droite*/, '\0', '\0'}, {'\0'/*Fleche bas*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '!', '\0'}}, <br />
{{'\0', 'x', 'w'}, {'\0', 'c', '\0'/*CTRL Droit*/}, {'*', '\n', '\0'}, {'\0'/*Pause*/, 'v', '\0'}, {'/', ',', '\0'}, {'\0'/*Verr Num*/, ';', '\0'}, {'\0'/*Touch window droite*/, ':', '\0'}, {'\0'/*Shift droit*/, '*', '\0'}}, <br />
{{'\0'/*Arret*/, 'z', 'a'}, {'\0'/*Options*/, 'e', '\0'}, {'9', '\0', '\0'}, {'\0', 'r', '\0'}, {'8', 'u', '\0'}, {'7', 'i', '\0'}, {'\0', 'o', '\0'}, {'*', 'p', '\0'}}, <br />
{{'\0', 's', 'q'}, {'\0'/*Touche window gauche*/, 'd', '\0'}, {'3', '\0', '\0'}, {'\n', 'f', '\0'}, {'2', 'j', '\0'}, {'1', 'k', '\0'}, {'\0', 'l', '\0'}, {'\0', 'm', '\0'}}, <br />
{{'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', 'w'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}}, <br />
{{'\0', '<', '\0'}, {'\0', '\0', '\0'}, {'.', '\0', '\0'}, {'\0', 'g', '\0'}, {'0', 'h', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '%', '\0'}}, <br />
{{'\0', '\0'/*MAJ*/, '\0'/*tab*/}, {'\0', '\0'/*F3*/, '\0'}, {'\0', 8, '\0'}, {'\0', 't', '\0'}, {'5', 'y', '\0'}, {'4', '$', '\0'}, {'\0', '\0'/*F7*/, '\0'}, {'\0'/*Shift gauche*/, '^', '\0'}}, <br />
{{'\0', '\0'/*F1*/, '\0'/*œ*/}, {'\0', '\0'/*F2*/, '\0'/*CTRL Gauche*/}, {'\0'/*Page haut*/, '\0'/*F9*/, '\0'}, {'\0'/*Debut*/, '(', '\0'}, {'\0'/*Insert*/, '-', '\0'}, {'\0'/*Supp*/, '=', '\0'}, {'t', '\n'/*F8*/, '\0'}, {'g', ')', '\0'}}<br />
};<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
<br />
Notre clavier ne supporte pas l'appuie de plusieurs touches en simultané à cause de la présence de décodeurs et d'encodeurs, le shift devient inutilisable, seulement maj est opérationnel. Afin de permettre l'utilisation de altgr, il fonctionnera comme le maj mais les deux ne pourront pas être activés en même temps.<br />
<br />
Nous avons tout d'abord mit des valeurs au hasard mais unique dans le tableau, puis nous avons identifié les touches pour une case dans le tableau, nous avons fait ce processus plusieurs fois afin de trouver toutes les cases des touches du clavier dans le tableau. Pour permettre l'utilisation du maj et du altgr, nous avons créer deux autres tableau comme ça, un chacun avec ses touches assignées. Lors de l'envoie, il faut vérifier dans quel mode nous nous trouvons pour envoyer le caractère dans le bon tableau (alt, maj ou classique).<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
while(1)<br />
{<br />
spi_select();<br />
uint8_t r=spi_exch(1);<br />
if (r != 1) printf("%c",r);<br />
spi_deselect();<br />
_delay_ms(20);<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void envoyer(){<br />
printf("Clavier attente\n");<br />
uint8_t message=spi_wait();<br />
printf("Clavier reçu %d\n",message);<br />
if (message == 1)<br />
spi_sendback(temp);<br />
printf("Clavier retour préparé %d\n",temp);<br />
<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Ici le shield (à gauche) va envoyer un 1 en SPI pour dire au clavier qu'il est prêt à l'écouter, si il reçoit autre chose qu'un 1 (son propre envoie) alors il l'affiche. Le clavier (à droite) va envoyer son dernier caractère dont la touche a été pressée lorsqu'il reçoit ce fameux 1.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_pingpong.mp4|vignette|alt=test clavier sur shield (sans démonstration de altgr et maj) |test clavier sur shield (sans démonstration de altgr et maj)|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Implémentation dans l'ordonnanceur===<br />
Pour pouvoir utiliser le clavier avec l'ordonnanceur, il suffit de faire de notre while(1) précédent, une tâche a part entière de notre ordonnanceur. Sur cet exemple on voit l'utilisation du alt et du maj.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_final.mp4|vignette|alt=test clavier avec ordonnancement |test clavier avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7356SE4Binome2024-52025-01-26T16:00:24Z<p>Adjadjaa : /* Différents Problèmes rencontrés */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu. (voir l'ajout de selectProcess dans l'ISR)<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en cascade pour réduire significativement le nombre de broches nécessaires. Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
Nous avons opté pour le décodeur 74HC138D (qui va envoyer un 0 parmi des 1) et trois encodeurs CD4532BM (qui cherche le premier 1 parmi des 0). On sent quand même les problèmes venir petit à petit.<br />
<p style="clear: both;" /><br />
[[Fichier:Clavier dell.png||thumb|right|800px|Clavier DELL]]<br />
<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|left|500px|Carte du clavier DELL]]<br />
<br />
[[Fichier:Matrice clavier dell.png||thumb|right|800px|Matrice du clavier DELL]]<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur : envoie un 0 parmi des 1.<br />
<br />
<u>CD4532BM</u><br />
* Encodeur : Nous avons étudié la datasheet et comment la mise en cascade fonctionne.<br />
[[Fichier:Cascade.png|vignette|alt=Mise en cascade des encodeurs.|Mise en cascade des encodeurs.]]<br />
On voit qu'un encodeur possède un bus de sortie de 5 bits. GS -> à l'état haut quand le composant reçoit un 1, 0 sinon. E0 -> à l'état haut quand il reçoit seulement des 0, 1 sinon. Puis Q2, Q1 ,Q0 la représentation binaire de l'entrée donnée.<br />
<br />
Afin de les mettre en cascade, il faut relié le E0 d'un premier encodeur au Ei de l'autre. Ensuite, nous allons faire un "OU" entre les GS afin de savoir si un des encodeurs reçoit un 1, puis grâce aux GS des deux premiers encodeurs nous sauront quelle encodeur à reçu le 1 (si les deux sont & 0 alors c'est le troisième). De même, faire une porte "OU" sur Q2, Q1, Q0 afin de réduire le nombre d'entrées/sorties nécessaires.<br />
<br />
<p style="clear: both;" /><br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en cascade des encodeurs.<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
====Carte après soudure des composants====<br />
<br />
===Différents Problèmes rencontrés===<br />
Avant même la réception de la carte, alors que nous commençons a essayé d'écrire un premier programme, nous nous rendions compte qu'envoyer un 0 parmi des 1 et de rechercher un 1 parmi des 0 ne fonctionnera pas (logique). Nous avons alors pris la décision de changer le décodeur car il était pour nous plus simple de changer un composant que les trois encodeurs. Nous avons opté pour lui de la même famille, le 74HTC238D.<br />
<br />
Dès la réception de la carte, nous avons effectué un premier test avec une simple programmation de LED. Nous nous sommes rapidement aperçus que nous avions configuré deux noms d'étiquettes de reset distinctes sur KiCad : une pour l'AVR (RST) et une pour le connecteur HE-10 (RESET). Cependant, seul le reset du connecteur HE-10 était correctement relié au microcontrôleur. Pour résoudre ce problème, nous avons simplement connecté les deux broches de reset à l'aide d'un fil.<br />
<br />
Lors de l'examen initial de notre carte, nous avons également constaté une erreur que nous avions commise. En effet, comme nous avions initialement conçu une matrice de touches sans encodeurs ni décodeurs, il n'était donc pas nécessaire d'intégrer des résistances de pull-up ou de pull-down. Nous avons alors juste rajouter ces composants, or il en résulte que lorsqu'une touche sera pressée, un 1 sera bien envoyé mais pas parmi des 0, parmi des états indéterminé. En général, les états indéterminés, on aime pas trop, surtout quand cela empêche ta carte de pouvoir fonctionner comme voulu. Il a donc été nécessaire d'ajouter des résistances de pull-down sur chaque colonne de notre clavier. Afin de simplifier cette modification, nous avons utilisé des résistances CMS que nous avons positionnées comme des dominos (verticalement), ce qui nous a permis de faire passer un fil de masse directement au-dessus des résistances.<br />
<br />
[[Fichier:Resistance pull Up domino.jpg|vignette|Résistances de Pull-down sur les colonnes]]<br />
<br />
Une fois tous ces problèmes de base résolus, nous avons enfin pu nous attaquer à la programmation du clavier. Pour vérifier que toutes les touches étaient correctement détectées, nous avons réalisé un petit programme de test ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]). Ce programme nous a permis d’associer chaque LED à un décodeur différent via la broche GS des décodeurs. Ainsi, nous avons pu identifier quelles touches ne répondaient pas. Premièrement, beaucoup de touches ne répondaient pas, moins d'une dizaine. Nous avons alors fait de multiples tests au multimètre sur notre carte mais aussi sur une autre matrice de touches similaire. Une des hypothèses fut qu'il fallait bien étamer les pistes pour permettre la conduction entre la carte et la matrice. Nous avons alors rajouter de l'étain, puis + de touches commençaient à fonctionner. Il fallait alors un nouveau programme de test pour détecter quelles lignes ou colonnes n'étaient pas bien étamés afin de permettre une conduction ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code de détection]). Il suffisait ainsi de rajouter de l'étain sur les colonnes et les lignes qui ne répondaient pas. Enfin, toutes les touches sont détectées lors de d'une pression !<br />
<br />
==Programmation de la carte==<br />
===Programme de test===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test])<br />
<br />
Afin de tester chaque touche de notre matrice, nous avons décidé de faire le programme le plus simple possible en utilisant les broches GS de nos encodeurs. Il n'y a pas d'histoire de ligne ou de colonnes ici, si une touche est pressée alors le GS de l'encodeur ou sa colonne est reliée passera à l'état haut. Une manière très simple de savoir si une touche est utilisable et si nos trois encodeurs sont opérationnels également. Nous avons trois leds pour trois encodeurs, pour chaque encodeur, s'allumera une led spécifique si il reçoit un 1 parmi des 0.<br />
<br />
Afin de mettre en place ce système, il nous faut un programme capable de balayer toutes les lignes de notre matrice via un décodeur.<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
int tab_outputs[8][3] = {<br />
{0, 0, 0},<br />
{1, 0, 0},<br />
{0, 1, 0},<br />
{1, 1, 0},<br />
{0, 0, 1},<br />
{1, 0, 1},<br />
{0, 1, 1},<br />
{1, 1, 1},<br />
};<br />
<br />
<br />
void maj_output(int lig){<br />
for (int i = 0 ; i < 3 ; i++){<br />
if (tab_outputs[lig][i] == 0){<br />
PORTC &= ~(1 << i);<br />
}<br />
else if (tab_outputs[lig][i] == 1){<br />
PORTC |= (1 << i);<br />
}<br />
}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<br />
[[Fichier:B5_test_matrice.mp4|vignette|alt=test d'une touche pressée |test d'une touche pressée|right|800px]]<br />
<br style="clear: both;" /><br />
Ici, grâce à l'initialisation d'un tableau de la représentation en binaire des chiffres 0 à 7, il suffit de faire une procédure qui prend en paramètre le numéro de ligne souhaitée puis de vérifier dans le tableau quelle sortie mettre à 0 et 1. Nous avions remarqué que mettre les sorties pour les décodeurs sur le même port côte à côte facilite la programmation.<br />
<br />
===Programme de détection===<br />
<br />
([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/detect.c Code du test])<br />
<br />
Dans le projet, nous avons eu des problèmes de lignes et colonnes qui n'était pas conduit entre notre carte et la matrice. Pour les identifier, nous avons mis en place un programme de détection qui lors de la pression d'une touche, va afficher grâce aux leds, de quel encodeur sa colonne régit puis quelle ligne et quelle colonne est activée. Ce programme permet ainsi de diagnostiquer rapidement les problèmes de conduction entre la carte et la matrice en identifiant précisément les correspondances défectueuses. <br />
<br />
Pour cela, nous avons imaginer deux fonctions show_ligne et show_colonne, permettant d'afficher sur nos trois leds la ligne et la colonne. Si les leds affichent : double clignotements de la led du milieu (allumée, éteint, allumé) puis (éteint, allumée, allumée) alors la ligne L6 (voir KiCad) et la 4e colonne du deuxième encodeur sont activées.<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_ligne(int i){<br />
turn_off_leds();<br />
for (int bit = 0; bit < 3; bit++){<br />
if (tab_outputs[i][bit] == 1) {<br />
PORTC |= (1 << (bit+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (bit+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}}<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void show_colonne(){<br />
turn_off_leds();<br />
for (int i = Q0; i < Q2 + 1 ; i++){<br />
if (((inputs >> i) & 1) == 1) {<br />
PORTC |= (1 << (i+LED1));<br />
}<br />
else <br />
PORTC &= ~(1 << (i+LED1));<br />
}<br />
_delay_ms(SHOW_TIME);<br />
turn_off_leds();<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Les deux fonctions se ressemblent beaucoup, la différence étant que show_ligne va prendre un paramètre un entier selon la ligne que nous voulons afficher alors que colonne va directement regarde dans le bus d'entrées la représentation binaire de la colonne activée. A noter que le fait que les LEDs et Q2, Q1, Q0 sont successivement placés sur le même port rend la programmation plus simple à réaliser.<br />
<br />
A noter la présence d'un 'uint8_t inputs;' où l'on va assigner PIND à chaque début d'une boucle, en effet pendant l'afficher l'utilisateur ne reste pas forcément la touche enfoncées ce qui changera les valeurs du bus d'entrée. Il est alors important de sauvegarder l'état de ce bus avant de l'afficher.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_detect.mp4|vignette|alt=test de la détection d'une touche |test de la détection d'une touche|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Ping pong===<br />
A l'aide des ressources envoyées par Mr.Redon, nous avons de quoi communiquer entre le shield et notre carte fille. Pour cela, nous avons du modifié un tout petit peu les programmes. En effet, nous avons ajouter un #define pour le Chip Select de notre clavier (le bon connecteur HE10 sur lequel nous allons le connecter) afin que ce soit bien lui qui sera sélectionné lors du spi_select et spi_deselect. Le shield va envoyer un 1 en SPI pour indiquer au clavier qu'il est sur écoute et qu'il attend un envoie de la carte fille.<br />
<br />
Cette communication va nous permettre de bien mapper toutes nos touches.<br />
<br />
Nous avons décidé de faire un tableau en 3 dimensions afin de faciliter le mapping. Pourquoi 3 dimensions ? Nous avons une première dimension pour le numéro de ligne (0 à 7), pour le numéro de colonne (0 à 7) puis pour le numéro d'encodeur (0 à 2). Le bus d'entrée nous donnant un numéro de ligne entre 0 et 7, nous avons trouvé plus facile de procéder de cette manière. Voici un exemple.<br />
<br />
<div style="float:center; width: 48%;"><syntaxhighlight lang="c" line="1"><br />
char tab_touches[8][8][3] = {<br />
{{'\0'/*AltGr*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'-', ' ', '\0'}, {'\0'/*Fleche gauche*/, 'b', '\0'}, {'\0'/*Fleche droite*/, '\0', '\0'}, {'\0'/*Fleche bas*/, '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '!', '\0'}}, <br />
{{'\0', 'x', 'w'}, {'\0', 'c', '\0'/*CTRL Droit*/}, {'*', '\n', '\0'}, {'\0'/*Pause*/, 'v', '\0'}, {'/', ',', '\0'}, {'\0'/*Verr Num*/, ';', '\0'}, {'\0'/*Touch window droite*/, ':', '\0'}, {'\0'/*Shift droit*/, '*', '\0'}}, <br />
{{'\0'/*Arret*/, 'z', 'a'}, {'\0'/*Options*/, 'e', '\0'}, {'9', '\0', '\0'}, {'\0', 'r', '\0'}, {'8', 'u', '\0'}, {'7', 'i', '\0'}, {'\0', 'o', '\0'}, {'*', 'p', '\0'}}, <br />
{{'\0', 's', 'q'}, {'\0'/*Touche window gauche*/, 'd', '\0'}, {'3', '\0', '\0'}, {'\n', 'f', '\0'}, {'2', 'j', '\0'}, {'1', 'k', '\0'}, {'\0', 'l', '\0'}, {'\0', 'm', '\0'}}, <br />
{{'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', 'w'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}}, <br />
{{'\0', '<', '\0'}, {'\0', '\0', '\0'}, {'.', '\0', '\0'}, {'\0', 'g', '\0'}, {'0', 'h', '\0'}, {'\0', '\0', '\0'}, {'\0', '\0', '\0'}, {'\0', '%', '\0'}}, <br />
{{'\0', '\0'/*MAJ*/, '\0'/*tab*/}, {'\0', '\0'/*F3*/, '\0'}, {'\0', 8, '\0'}, {'\0', 't', '\0'}, {'5', 'y', '\0'}, {'4', '$', '\0'}, {'\0', '\0'/*F7*/, '\0'}, {'\0'/*Shift gauche*/, '^', '\0'}}, <br />
{{'\0', '\0'/*F1*/, '\0'/*œ*/}, {'\0', '\0'/*F2*/, '\0'/*CTRL Gauche*/}, {'\0'/*Page haut*/, '\0'/*F9*/, '\0'}, {'\0'/*Debut*/, '(', '\0'}, {'\0'/*Insert*/, '-', '\0'}, {'\0'/*Supp*/, '=', '\0'}, {'t', '\n'/*F8*/, '\0'}, {'g', ')', '\0'}}<br />
};<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
<br />
Notre clavier ne supporte pas l'appuie de plusieurs touches en simultané à cause de la présence de décodeurs et d'encodeurs, le shift devient inutilisable, seulement maj est opérationnel. Afin de permettre l'utilisation de altgr, il fonctionnera comme le maj mais les deux ne pourront pas être activés en même temps.<br />
<br />
Nous avons tout d'abord mit des valeurs au hasard mais unique dans le tableau, puis nous avons identifié les touches pour une case dans le tableau, nous avons fait ce processus plusieurs fois afin de trouver toutes les cases des touches du clavier dans le tableau. Pour permettre l'utilisation du maj et du altgr, nous avons créer deux autres tableau comme ça, un chacun avec ses touches assignées. Lors de l'envoie, il faut vérifier dans quel mode nous nous trouvons pour envoyer le caractère dans le bon tableau (alt, maj ou classique).<br />
<br />
<div style="float:left; width: 48%; padding-left: 25px;"><syntaxhighlight lang="c" line="1"><br />
while(1)<br />
{<br />
spi_select();<br />
uint8_t r=spi_exch(1);<br />
if (r != 1) printf("%c",r);<br />
spi_deselect();<br />
_delay_ms(20);<br />
}<br />
</syntaxhighlight></div><br />
<br />
<div style="float:right; width: 48%; padding-right: 25px;"><syntaxhighlight lang="c" line="1"><br />
void envoyer(){<br />
printf("Clavier attente\n");<br />
uint8_t message=spi_wait();<br />
printf("Clavier reçu %d\n",message);<br />
if (message == 1)<br />
spi_sendback(temp);<br />
printf("Clavier retour préparé %d\n",temp);<br />
<br />
}<br />
</syntaxhighlight></div><br />
<br style="clear: both;" /><br />
Ici le shield (à gauche) va envoyer un 1 en SPI pour dire au clavier qu'il est prêt à l'écouter, si il reçoit autre chose qu'un 1 (son propre envoie) alors il l'affiche. Le clavier (à droite) va envoyer son dernier caractère dont la touche a été pressée lorsqu'il reçoit ce fameux 1.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_pingpong.mp4|vignette|alt=test clavier sur shield (sans démonstration de altgr et maj) |test clavier sur shield (sans démonstration de altgr et maj)|center|800px]]<br />
<br style="clear: both;" /><br />
<br />
===Implémentation dans l'ordonnanceur===<br />
Pour pouvoir utiliser le clavier avec l'ordonnanceur, il suffit de faire de notre while(1) précédent, une tâche a part entière de notre ordonnanceur. Sur cet exemple on voit l'utilisation du alt et du maj.<br />
<br style="clear: both;" /><br />
[[Fichier:B5_test_final.mp4|vignette|alt=test clavier avec ordonnancement |test clavier avec ordonnancement|center|800px]]<br />
<br style="clear: both;" /></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Resistance_pull_Up_domino.jpg&diff=7355Fichier:Resistance pull Up domino.jpg2025-01-26T15:59:47Z<p>Adjadjaa : </p>
<hr />
<div>Resistance pull Up domino</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7279SE4Binome2024-52025-01-25T21:45:07Z<p>Adjadjaa : /* Carte Fille Matrice de touches */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur<br />
<br />
<u>CD4532BM</u><br />
* Encodeur<br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en parallèle des encodeurs<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
====Carte après soudure des composants====<br />
<br />
===Différents Problèmes rencontrés===<br />
Dès la réception de la carte, nous avons effectué un premier test avec une simple programmation de LED. Nous nous sommes rapidement aperçus que nous avions configuré deux broches de reset distinctes : une pour l'AVR et une pour le connecteur HE-10. Cependant, seul le reset du connecteur HE-10 était correctement relié au microcontrôleur. Pour résoudre ce problème, nous avons simplement connecté les deux broches de reset à l'aide d'un fil.<br />
<br />
Lors de l'examen initial de notre carte, nous avons également constaté une erreur que nous avions commise. En effet, comme nous avions initialement conçu une matrice de touches sans encodeurs ni décodeurs, il n'était donc pas nécessaire d'intégrer des résistances de pull-up ou de pull-down. Il a donc été nécessaire d'ajouter des résistances de pull-down sur chaque colonne de notre clavier. Afin de simplifier cette modification, nous avons utilisé des résistances CMS que nous avons positionnées comme des dominos, ce qui nous a permis de faire passer un fil de masse directement au-dessus des résistances.<br />
<br />
<br />
Une fois tous ces problèmes de base résolus, nous avons enfin pu nous attaquer à la programmation du clavier. Pour vérifier que toutes les touches étaient correctement détectées, nous avons réalisé un petit programme de test ([https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/prog/test.c Code du test]). Ce programme nous a permis d’associer chaque LED à un décodeur différent via la broche GS des décodeurs. Ainsi, nous avons pu identifier quelles touches ne répondaient pas.<br />
<br />
Ensuite, nous avons analysé les lignes et colonnes communes aux touches défectueuses pour mieux cerner l’origine du problème. À ce stade, nous avons constaté que la majorité des touches n’étaient pas détectées. Après réflexion, nous avons supposé que le problème venait probablement d’une mauvaise interconnexion entre notre carte et la matrice de touches. Pour corriger cela, nous avons soigneusement étamé les pistes afin d’assurer une meilleure conduction. Nous avons répété l’opération 3 à 4 fois pour trouver la quantité idéale d’étain et garantir une connexion fiable.</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7278SE4Binome2024-52025-01-25T20:52:46Z<p>Adjadjaa : /* Hardware */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur<br />
<br />
<u>CD4532BM</u><br />
* Encodeur<br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en parallèle des encodeurs<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
<br />
====Carte après soudure des composants====</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=7001SE4Binome2024-52024-12-18T13:20:54Z<p>Adjadjaa : /* Kicad */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur<br />
<br />
<u>CD4532BM</u><br />
* Encodeur<br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en parallèle des encodeurs<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
Pour réaliser la carte fille, nous avions dans un premier temps conçu une carte avec une matrice de touches directement implenter sur celle-ci, mais jugeant que cela était trop simple nous avons été redirigé vers l'utilisation d'une matrice déjà réalisé. Ainsi nous avons avons reutiliser celle d'un vieux clavier dell en créant les empreintes à la bonne taille pour se connecter sur la matrice<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
====Reçu carte vierge====<br />
<br />
====Carte après soudure des composants====</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6873SE4Binome2024-52024-11-20T11:17:13Z<p>Adjadjaa : /* Kicad */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur<br />
<br />
<u>CD4532BM</u><br />
* Encodeur<br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en parallèle des encodeurs<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
TEXTE à REMPLIR<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|600px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
====Reçu carte vierge====<br />
<br />
====Carte après soudure des composants====</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6872SE4Binome2024-52024-11-20T11:16:30Z<p>Adjadjaa : /* Kicad */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur<br />
<br />
<u>CD4532BM</u><br />
* Encodeur<br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en parallèle des encodeurs<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
<br />
TEXTE à REMPLIR<br />
<br />
[[Fichier:Pcb recto carte fille clavier dell.png|left|480px|vignette|Avant du PCB]][[Fichier:Pcb verso carte fille clavier dell.png|right|480px|vignette|Arrière du PCB]]<br />
<br />
[[Fichier:Capture d’écran 2024-11-20 à 12.09.07.png|left|480px|vignette|PCB vue 3D avant]][[Fichier:Capture d’écran 2024-11-20 à 12.09.33.png|right|480px|vignette|PCB vue 3D arrière]]<br />
<br style="clear: both;" /><br />
====Reçu carte vierge====<br />
<br />
====Carte après soudure des composants====</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Capture_d%E2%80%99%C3%A9cran_2024-11-20_%C3%A0_12.09.33.png&diff=6871Fichier:Capture d’écran 2024-11-20 à 12.09.33.png2024-11-20T11:15:41Z<p>Adjadjaa : </p>
<hr />
<div>e</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Capture_d%E2%80%99%C3%A9cran_2024-11-20_%C3%A0_12.09.07.png&diff=6870Fichier:Capture d’écran 2024-11-20 à 12.09.07.png2024-11-20T11:15:21Z<p>Adjadjaa : </p>
<hr />
<div>e</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Pcb_verso_carte_fille_clavier_dell.png&diff=6868Fichier:Pcb verso carte fille clavier dell.png2024-11-20T11:10:03Z<p>Adjadjaa : </p>
<hr />
<div>pcb verso carte fille clavier dell</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Pcb_recto_carte_fille_clavier_dell.png&diff=6867Fichier:Pcb recto carte fille clavier dell.png2024-11-20T11:09:41Z<p>Adjadjaa : </p>
<hr />
<div>pcb recto carte fille clavier dell</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6866SE4Binome2024-52024-11-20T11:07:48Z<p>Adjadjaa : /* Hardware */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur<br />
<br />
<u>CD4532BM</u><br />
* Encodeur<br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en parallèle des encodeurs<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
[[Fichier:Schematique carte fille clavier dell.png|center|1000px|vignette|Schématique de la carte Fille]]<br />
====Reçu carte vierge====<br />
<br />
====Carte après soudure des composants====</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Schematique_carte_fille_clavier_dell.png&diff=6865Fichier:Schematique carte fille clavier dell.png2024-11-20T11:07:03Z<p>Adjadjaa : </p>
<hr />
<div>Schematique carte fille clavier dell</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6864SE4Binome2024-52024-11-20T11:05:37Z<p>Adjadjaa : /* Détails des composants */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
<u>ATmega328P</u><br />
* Micro-contrôleur<br />
<br />
<u>74HC138D</u><br />
* Décodeur<br />
<br />
<u>CD4532BM</u><br />
* Encodeur<br />
<br />
<u>74LS32</u><br />
* Porte logique Or pour la mise en parallèle des encodeurs<br />
<br />
<u>Connecteur HE10</u><br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
<u>Connecteur de la matrice</u><br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
<u>AVR-ISP-6</u><br />
* Programmateur AVR<br />
<br />
<u>LED_SMD</u><br />
* 3 LEDs<br />
<br />
== Hardware ==<br />
===Kicad===<br />
<br />
====Reçu carte vierge====<br />
<br />
====Carte après soudure des composants====</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6863SE4Binome2024-52024-11-20T11:01:20Z<p>Adjadjaa : /* Carte Fille Matrice de touches */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
=== Détails des composants ===<br />
<br />
==== ATmega328P ====<br />
* Micro-contrôleur<br />
<br />
==== 74HC138D ====<br />
* Décodeur<br />
<br />
==== CD4532BM ====<br />
* Encodeur<br />
<br />
==== 74LS32 ====<br />
* Porte logique Or pour la mise en parallèle des encodeurs<br />
<br />
==== Connecteur HE10 ====<br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
==== Connecteur de la matrice ====<br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
==== AVR-ISP-6 ====<br />
* Programmateur AVR<br />
<br />
==== LED_SMD ====<br />
* 3 LEDs<br />
<br />
<br />
== Hardware ==<br />
===Kicad===<br />
<br />
====Reçu carte vierge====<br />
<br />
====Carte après soudure des composants====</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6861SE4Binome2024-52024-11-20T10:58:51Z<p>Adjadjaa : /* Carte Fille Matrice de touches */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
== Détails des composants ==<br />
<br />
=== ATmega328P ===<br />
* Micro-contrôleur<br />
<br />
=== 74HC138D ===<br />
* Décodeur<br />
<br />
=== CD4532BM ===<br />
* Encodeur<br />
<br />
=== 74LS32 ===<br />
* Porte logique Or pour la mise en parallèle des encodeurs<br />
<br />
=== Connecteur HE10 ===<br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
=== Connecteur de la matrice ===<br />
* Simplement une empreinte que l'on a créé [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers la bibliothèque présent sur le git]<br />
<br />
=== AVR-ISP-6 ===<br />
* Programmateur AVR<br />
<br />
=== LED_SMD ===<br />
* 3 LEDs<br />
<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6859SE4Binome2024-52024-11-20T10:57:19Z<p>Adjadjaa : /* Carte Fille Matrice de touches */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
== Détails des composants ==<br />
<br />
=== ATmega328P ===<br />
* Micro-contrôleur<br />
<br />
=== 74HC138D ===<br />
* Décodeur<br />
<br />
=== CD4532BM ===<br />
* Encodeur<br />
<br />
=== 74LS32 ===<br />
* Porte logique Or pour la mise en parallèle des encodeurs<br />
<br />
=== Connecteur HE10 ===<br />
* Connecteur pour la liaison PicoShield-CarteFille<br />
<br />
=== Connecteur de la matrice ===<br />
* Simplement une empreinte que l'on a créé[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/CF_Clavier/Footprint_KeyboardDell_DJADJA Lien vers le git]<br />
<br />
=== AVR-ISP-6 ===<br />
* Programmateur AVR<br />
<br />
=== LED_SMD ===<br />
* 3 LEDs<br />
<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6851SE4Binome2024-52024-11-20T10:37:13Z<p>Adjadjaa : /* Explications générales sur la réalisation de la carte */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
[[Fichier:Connecteur de base clavier dell.png||thumb|right|200px|Matrice du clavier DELL]]<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
<p style="clear: both;" /><br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6850SE4Binome2024-52024-11-20T10:32:59Z<p>Adjadjaa : /* Carte Fille Matrice de touches */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
[[Fichier:Clavier dell.png||thumb|right|300px|Clavier DELL]]<br />
[[Fichier:Matrice clavier dell.png||thumb|right|300px|Matrice du clavier DELL]]<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<p style="clear: both;" /><br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Connecteur_de_base_clavier_dell.png&diff=6846Fichier:Connecteur de base clavier dell.png2024-11-20T10:23:55Z<p>Adjadjaa : </p>
<hr />
<div>Connecteur de base clavier dell</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Matrice_clavier_dell.png&diff=6844Fichier:Matrice clavier dell.png2024-11-20T10:19:54Z<p>Adjadjaa : </p>
<hr />
<div>Matrice clavier dell</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6843SE4Binome2024-52024-11-20T10:17:48Z<p>Adjadjaa : /* Carte Fille Matrice de touches */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
[[Fichier:Clavier dell.png||thumb|right|400px]]<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Clavier_dell.png&diff=6841Fichier:Clavier dell.png2024-11-20T10:16:28Z<p>Adjadjaa : </p>
<hr />
<div>clavier dell</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6839SE4Binome2024-52024-11-20T10:08:19Z<p>Adjadjaa : /* Carte Fille Matrice de touches */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
= Carte Fille Matrice de touches =<br />
==Explications générales sur la réalisation de la carte==<br />
<br />
Pour concevoir la carte fille dédiée au clavier, nous avons réutilisé un ancien clavier DELL équipé d’une matrice déjà fonctionnelle. L’idée consiste à connecter les sorties de cette matrice directement à notre carte fille à l’aide d’un connecteur adapté.<br />
<br />
Cependant, un défi se pose : la matrice du clavier comprend un total de 26 sorties (sans compter les LED et autres signaux). Cela dépasse largement les capacités en nombre de broches d’un ATmega328P.<br />
<br />
Pour remédier à ce problème, nous avons mis en place une solution d’encodage. Nous avons utilisé un décodeur (3 vers 8) pour gérer les lignes et trois encodeurs (8 vers 3) pour gérer les colonnes. Les encodeurs sont montés en parallèle pour réduire significativement le nombre de broches nécessaires.Cette solution permet de maximiser les ressources du microcontrôleur tout en gérant efficacement les signaux de la matrice.<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6752SE4Binome2024-52024-11-18T11:08:34Z<p>Adjadjaa : /* Carte Shield */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|300px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6751SE4Binome2024-52024-11-18T11:07:37Z<p>Adjadjaa : /* Carte Shield */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|center|350px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|right|300px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6750SE4Binome2024-52024-11-18T11:07:10Z<p>Adjadjaa : /* Carte Shield */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|left|thumb|350px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|right|300px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6749SE4Binome2024-52024-11-18T11:06:38Z<p>Adjadjaa : /* Carte Shield */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|center|350px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|right|300px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettre la tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6747SE4Binome2024-52024-11-18T11:06:18Z<p>Adjadjaa : /* Carte Shield */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|center|350px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|right|350px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un _delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettrela tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6745SE4Binome2024-52024-11-18T11:04:37Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un __delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettrela tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6744SE4Binome2024-52024-11-18T11:02:55Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Shield après soudure des composants ==<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
==Test==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
== Ordonnanceur ==<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
=== Processus ===<br />
==== Structure ====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
==== Etat d'un processus ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
==== Procédures principales ====<br />
<br />
=== ISR ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
==== Séléction de processus ====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
=== Test ===<br />
==== Clignotement de deux LED à fréquences indivisibles entre elles ====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un __delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
==== Clignotement grâce à l'état endormi ====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettrela tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6742SE4Binome2024-52024-11-18T11:01:05Z<p>Adjadjaa : /* Ordonnanceur = */</p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
== Hardware ==<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
=== Carte Shield après soudure des composants ===<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Software ==<br />
===Test===<br />
==== Allumage de LEDS sur Programmateur AVR ====<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
==== Lecture de la carte SD ====<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
==== Connecteurs IDC HE10 ====<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
=== Ordonnanceur ===<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
==== Processus ====<br />
===== Structure =====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
===== Etat d'un processus =====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
===== Procédures principales =====<br />
<br />
==== ISR ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
===== Séléction de processus =====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
==== Test ====<br />
===== Clignotement de deux LED à fréquences indivisibles entre elles =====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un __delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
===== Clignotement grâce à l'état endormi =====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettrela tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6741SE4Binome2024-52024-11-18T11:00:36Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
== Hardware ==<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
=== Carte Shield après soudure des composants ===<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Software ==<br />
===Test===<br />
==== Allumage de LEDS sur Programmateur AVR ====<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
==== Lecture de la carte SD ====<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
==== Connecteurs IDC HE10 ====<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
=== Ordonnanceur ====<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
==== Processus ====<br />
===== Structure =====<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
===== Etat d'un processus =====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
===== Procédures principales =====<br />
<br />
==== ISR ====<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
===== Séléction de processus =====<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
==== Test ====<br />
===== Clignotement de deux LED à fréquences indivisibles entre elles =====<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un __delay_ms).<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
_delay_ms(200);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
<br />
===== Clignotement grâce à l'état endormi =====<br />
Nous ajoutons l'état endormi afin que nos tâches ne mettent pas en pause l'ordonnanceur avec un _delay_ms. Pour cela, nous incorporons une fonction makeSleep qui permet de mettrela tâche qui l'appelle dans cet état.<br />
<br />
<br />
<br />
<div style="float:left; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
void makeSleep(int t){<br />
table_process[indice_tache].etat.id = SLEEPY;<br />
table_process[indice_tache].etat.time.sleepingtime = t;<br />
TIMER1_COMPA_vect();}<br />
void tache1(void){<br />
while (1){<br />
PORTC ^= (1 << PC0);<br />
_delay_ms(300);}}<br />
void tache3(void){<br />
while (1){<br />
PORTC ^= (1 << PC3);<br />
//_delay_ms(1000);<br />
makeSleep(1000);}}<br />
void tache2(void){<br />
while (1){<br />
PORTD ^= (1 << PD7);<br />
//_delay_ms(1000);<br />
makeSleep(700);}}<br />
</syntaxhighlight></div><br />
[[Fichier:B5_test2.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
<br style="clear: both;" /><br />
A noter que la première tâche executée ne doit pas être endormie.<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6708SE4Binome2024-52024-11-18T10:00:41Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
== Hardware ==<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
=== Carte Shield après soudure des composants ===<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Software ==<br />
===Test===<br />
==== Allumage de LEDS sur Programmateur AVR ====<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
==== Lecture de la carte SD ====<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
==== Connecteurs IDC HE10 ====<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===<br />
<br />
= Ordonnanceur =<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
== Processus ==<br />
=== Structure ===<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
=== Etat d'un processus ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
=== Procédures principales ===<br />
<br />
== ISR ==<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
=== Séléction de processus ===<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
== Test ==<br />
=== Clignotement de deux LED à fréquences indivisibles entre elles ===<br />
[[Fichier:B5_test1.mp4|vignette|alt=test des frequences imprevisibles|test des frequences imprevisibles]]<br />
===<br />
Afin de vérifier la réussite de notre ordonnanceur à fonctionnement tourniquet, nous avons programmer deux simples tâches changeant l'état d'une LED. Une à une fréquence 200ms et l'autre 300ms (avec un __delay_ms).</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6698SE4Binome2024-52024-11-18T09:53:46Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
== Hardware ==<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
=== Carte Shield après soudure des composants ===<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Software ==<br />
=== Test Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds. [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink Code du test]<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Test de lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo Code du test]<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Test des connecteurs IDC HE10 ===<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
<br />
= Carte Fille Matrice de touches =<br />
<br />
== Carte ==<br />
<br />
=== Fille après soudure des composants ===<br />
<br />
= Ordonnanceur =<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
== Processus ==<br />
=== Structure ===<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes d'états que nous pourrons ajouter pendant la progression du projet.<br />
<br />
=== Etat d'un processus ===<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
typedef union {<br />
int sleepingtime; <br />
} Time;<br />
<br />
typedef struct {<br />
int id;<br />
Time time;<br />
} Etat ;<br />
</syntaxhighlight></div><br />
<br />
L'état d'un processus est alors une structure à deux champs (pour l'instant), l'id doit correspondre à un '#DEFINE' pour avoir un sens tandis que nous avons choisi de faire une union pour le temps qui caractérise notre état afin qu'il puisse avoir un nom et type de variable cohérent avec son état.(Ici seulement sleepingtime car seul l'état endormi existe pour le moment)<br />
<br />
<div style="text-align: center;"><br />
{| class="wikitable"<br />
|+ Tableau des états<br />
|-<br />
! Etat !! ACTIVE !! SLEEPY !! ... !! ...<br />
|-<br />
| Id || 0 || 1 || ... || ...<br />
|}<br />
</div><br />
<br />
=== Procédures principales ===<br />
<br />
== ISR ==<br />
<div style="float:right; width: 48%; padding-left: 100px;"><syntaxhighlight lang="c" line="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED) // Procédure d'interruption<br />
{<br />
TCNT1=0;//reset timer<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_REGISTERS();<br />
table_process[indice_tache].adressePile = SP;<br />
/* Appel à l'ordonnanceur */<br />
selectProcess();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = table_process[indice_tache].adressePile;<br />
portRESTORE_REGISTERS();<br />
<br />
asm volatile ( "reti" );<br />
}<br />
</syntaxhighlight></div><br />
<br />
L'ISR est ce qu'il va être executer lors des interruptions toutes les 20 millisecondes. Cela consiste à sauvegarder tous les registres de la tâche qui était en cours avant l'appel de l'ISR pour ensuite passer à la tâche suivante valide (c'est à dire active) sans oublier de charger les registres de la nouvelle tâche.<br />
<br />
Nous devons également, à chaque fois avant de changer de tâche, enregistrer le pointeur de pile dans le processus afin de pouvoir revenir là ou elle en est la prochaine fois qu'elle sera appelée. Respectivement, une fois la nouvelle tâche choisie, le pointeur de pile doit prendre l'adresse de là ou en était la tâche avant qu'elle soit interrompue.<br />
<br style="clear: both;" /><br />
<br />
=== Séléction de processus ===<br />
Lors de la séléction de processus, nous devons parcourir tous les processus jusqu'au moment où nous en trouvons un actif. Ainsi, il deviendra la tâche que nous traiterons lors du prochain intervalle de 20 ms. A ce stade, à chaque fois que la procédure selectProcess est appelée, nous devons réduire le temps de repos de chaque process endormi de 20 ms. D'autres conditions pourrons être ajoutée si ajout d'état a lieu.<br />
<br />
== Test ==<br />
=== Clignotement de deux LED à fréquences indivisibles ===</div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6599SE4Binome2024-52024-11-13T10:11:56Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Shield après soudure des composants ==<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Allumage de LEDS sur Programmateur AVR ==<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
== Test de lecture de la carte SD ==<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
== Test des connecteurs IDC HE10 ==<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
<br />
= Carte Fille =<br />
<br />
== Carte Fille après soudure des composants ==<br />
<br />
= Ordonnanceur =<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
== Processus ==<br />
=== Structure principale ===<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes détat que nous pourrons ajouter pendant la progression du projet.<br />
<br />
=== Etat d'un processus ===<br />
<br />
==Coder le tableau des structures des processus==<br />
Ce tableau des structures permet à un process d'ếtre caractériser par l'adresse du début de sa pile, l'adresse de la tâche (procédure) qu'elle va effectuer pui sont état (1 : réveillé, 0 : endormi). <br />
<syntaxhighlight lang="c" line><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
bool etat; //état du processus (1 ou 0)<br />
} Process;<br />
<br />
Process table_process[MAXPROCESS];<br />
</syntaxhighlight><br />
<br />
==Coder la fonction d'initialisation de la pile d'un processus==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
<br />
==Taches ∞ pour faire clignoter deux leds à 2 fréquences premières entre elle==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
[[Fichier:Ordonnanceur cligno led.mp4|vignette|thumb|center|700px|Clignotement des leds à des fréquences premières entre elle avec l'ordonnanceur]]<br />
<br />
==Lancement des deux tâches en parallèle grâce à l'ordonnanceur à tourniquet==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6598SE4Binome2024-52024-11-13T10:11:25Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki documente le développement d’un pico-ordinateur modulaire. Ce dernier est constitué d’une carte principale, composée d’une carte Shield permettant la connexion des cartes filles, et d’une carte mère (initialement simulée par une Arduino Uno avant sa conception finale). Plusieurs cartes filles sont prévues, chacune remplissant une fonction spécifique : gestion du clavier, affichage, port série, réseau, mémoire de masse et son.<br />
<br />
Notre binôme est spécifiquement chargé du développement de la carte fille dédiée au clavier.<br />
<br />
Toutes les ressources nécessaires, incluant les codes sources et les schémas, sont disponibles sur le dépôt Git suivant : Lien vers le Git.<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Shield après soudure des composants ==<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Allumage de LEDS sur Programmateur AVR ==<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
== Test de lecture de la carte SD ==<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
== Test des connecteurs IDC HE10 ==<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
<br />
= Carte Fille =<br />
<br />
== Carte Fille après soudure des composants ==<br />
<br />
= Ordonnanceur =<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
== Processus ==<br />
=== Structure principale ===<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes détat que nous pourrons ajouter pendant la progression du projet.<br />
<br />
=== Etat d'un processus ===<br />
<br />
==Coder le tableau des structures des processus==<br />
Ce tableau des structures permet à un process d'ếtre caractériser par l'adresse du début de sa pile, l'adresse de la tâche (procédure) qu'elle va effectuer pui sont état (1 : réveillé, 0 : endormi). <br />
<syntaxhighlight lang="c" line><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
bool etat; //état du processus (1 ou 0)<br />
} Process;<br />
<br />
Process table_process[MAXPROCESS];<br />
</syntaxhighlight><br />
<br />
==Coder la fonction d'initialisation de la pile d'un processus==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
<br />
==Taches ∞ pour faire clignoter deux leds à 2 fréquences premières entre elle==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
[[Fichier:Ordonnanceur cligno led.mp4|vignette|thumb|center|700px|Clignotement des leds à des fréquences premières entre elle avec l'ordonnanceur]]<br />
<br />
==Lancement des deux tâches en parallèle grâce à l'ordonnanceur à tourniquet==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6595SE4Binome2024-52024-11-13T10:10:07Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki présente le développement d'un pico-ordinateur. Il sera composé d'une carte principale, composé d'une carte shield permettant la connexion des cartes filles et d'une carte mère (arduino uno avant la réalisation de celle-ci),et de différentes cartes filles assurant les fonctions suivantes: clavier, affichage, port série, réseau, mémoire de masse et son. Notre binôme sera en charge de la carte fille clavier. Les ressources nécessaires, y compris les codes sources et les schémas, sont accessibles via le dépôt Git suivant : [https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git Lien du Git]<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Shield après soudure des composants ==<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Allumage de LEDS sur Programmateur AVR ==<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
== Test de lecture de la carte SD ==<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
== Test des connecteurs IDC HE10 ==<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
<br />
= Carte Fille =<br />
<br />
== Carte Fille après soudure des composants ==<br />
<br />
= Ordonnanceur =<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
== Processus ==<br />
=== Structure principale ===<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes détat que nous pourrons ajouter pendant la progression du projet.<br />
<br />
=== Etat d'un processus ===<br />
<br />
==Coder le tableau des structures des processus==<br />
Ce tableau des structures permet à un process d'ếtre caractériser par l'adresse du début de sa pile, l'adresse de la tâche (procédure) qu'elle va effectuer pui sont état (1 : réveillé, 0 : endormi). <br />
<syntaxhighlight lang="c" line><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
bool etat; //état du processus (1 ou 0)<br />
} Process;<br />
<br />
Process table_process[MAXPROCESS];<br />
</syntaxhighlight><br />
<br />
==Coder la fonction d'initialisation de la pile d'un processus==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
<br />
==Taches ∞ pour faire clignoter deux leds à 2 fréquences premières entre elle==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
[[Fichier:Ordonnanceur cligno led.mp4|vignette|thumb|center|700px|Clignotement des leds à des fréquences premières entre elle avec l'ordonnanceur]]<br />
<br />
==Lancement des deux tâches en parallèle grâce à l'ordonnanceur à tourniquet==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6591SE4Binome2024-52024-11-13T10:08:05Z<p>Adjadjaa : </p>
<hr />
<div>=Introduction=<br />
<br />
Ce wiki présente le développement d'un pico-ordinateur. Il sera composé d'une carte principale, composé d'une carte shield permettant la connexion des cartes filles et d'une carte mère (arduino uno avant la réalisation de celle-ci),et de différentes cartes filles assurant les fonctions suivantes: clavier, affichage, port série, réseau, mémoire de masse et son. Notre binôme sera en charge de la carte fille clavier. Les ressources nécessaires, y compris les codes sources et les schémas, sont accessibles via le dépôt Git suivant : https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git<br />
<br />
Carte fille clavier "matrice de touches"<br />
<br />
= Carte Shield =<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Shield après soudure des composants ==<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Allumage de LEDS sur Programmateur AVR ==<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
== Test de lecture de la carte SD ==<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
== Test des connecteurs IDC HE10 ==<br />
Afin de tester nos connecteur HE10, nous avons utilisé un afficher 7 segments (Sparkfun 7 segments display). Pour pouvoir vérifier leurs fonctionnements nous avons branché l'afficheur sur chaque connecteur tour à tour. Le programme implanté est un simple connecteur à afficher sur l'afficheur. Voici une vidéo du compteur fonctionnant sur un des 5 connecteurs HE10. ([https://learn.sparkfun.com/tutorials/using-the-serial-7-segment-display/all Code ici (section : Example 2 SPI)])<br />
<br />
[[Fichier:Se4-5-7segments.mp4|vignette|alt=se4-5-7segments|Test connecteur HE10 avec afficheur 7 segments.|center]]<br />
<br />
= Carte Fille =<br />
<br />
== Carte Fille après soudure des composants ==<br />
<br />
= Ordonnanceur =<br />
Pour les interruptions de notre ordonnanceur nous avons utilisé la procédure d'initialisation du minuteur avec le Timer1 disponible dans les cours de Mr.Redon en renseignant une période de 20ms. Nous l'avons disposé dans le fichier minuteur.c car nous n'allons plus le modifier pour le reste du projet. Dans un autre fichier process.c (avec process.h), nous allons y mettre nos structures pour les process et leurs états puis une union pour le temps qui le caractérise ainsi que toutes les fonctions associés.<br />
<br />
[https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/Ordonnanceur Lien du répertoire]<br />
<br />
== Processus ==<br />
=== Structure principale ===<br />
<div style="float:right; width: 48%; padding-left: 10px;"><syntaxhighlight lang="c" line="1"><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
Etat etat; <br />
} Process;<br />
</syntaxhighlight></div><br />
<br />
Notre structure caractérisant un processus est définie par les trois champs ci-contre.<br />
<br />
Une adresse de départ correspondant à la fonction du processus associé, l'adresse où se situe le processus dans la pile puis l'état de la tâche. Nous avons décidé de faire une structure à part entière compte tenu des multitudes détat que nous pourrons ajouter pendant la progression du projet.<br />
<br />
=== Etat d'un processus ===<br />
<br />
==Coder le tableau des structures des processus==<br />
Ce tableau des structures permet à un process d'ếtre caractériser par l'adresse du début de sa pile, l'adresse de la tâche (procédure) qu'elle va effectuer pui sont état (1 : réveillé, 0 : endormi). <br />
<syntaxhighlight lang="c" line><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
bool etat; //état du processus (1 ou 0)<br />
} Process;<br />
<br />
Process table_process[MAXPROCESS];<br />
</syntaxhighlight><br />
<br />
==Coder la fonction d'initialisation de la pile d'un processus==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
<br />
==Taches ∞ pour faire clignoter deux leds à 2 fréquences premières entre elle==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
[[Fichier:Ordonnanceur cligno led.mp4|vignette|thumb|center|700px|Clignotement des leds à des fréquences premières entre elle avec l'ordonnanceur]]<br />
<br />
==Lancement des deux tâches en parallèle grâce à l'ordonnanceur à tourniquet==<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6299SE4Binome2024-52024-10-15T13:47:43Z<p>Adjadjaa : /* Carte Shield */</p>
<hr />
<div>git : https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git<br />
<br />
Carte fille clavier "matrice de touches"<br />
=Hardware=<br />
<br />
== Carte Shield ==<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Shield après soudure des composants ==<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Fille ==<br />
<br />
== Carte Fille après soudure des composants ==<br />
<br />
= Software =<br />
== Carte Shield ==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Test de lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Test des connecteurs IDC HE10 ===<br />
<br />
<br />
<br />
=== Ordonnanceur===<br />
==== Allumer la LED broche PB5 avec Timer1 ISR ====<br />
<br />
<br />
<syntaxhighlight lang="c" line><br />
#define CTC1 WGM12 // Meilleur nom pour le bit<br />
<br />
#define PERIODE 20<br />
<br />
void init_minuteur(int diviseur,long periode){<br />
TCCR1A=0; // Le mode choisi n'utilise pas ce registre<br />
TCCR1B=(1<<CTC1); // Réinitialisation du minuteur sur expiration<br />
switch(diviseur){<br />
case 8: TCCR1B |= (1<<CS11); break;<br />
case 64: TCCR1B |= (1<<CS11 | 11<<CS10); break;<br />
case 256: TCCR1B |= (1<<CS12); break;<br />
case 1024: TCCR1B |= (1<<CS12 | 1<<CS10); break;<br />
}<br />
// Un cycle prend 1/F_CPU secondes.<br />
// Un pas de compteur prend diviseur/F_CPU secondes.<br />
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas<br />
// soit (periode*F_CPU)/(1000*diviseur)<br />
OCR1A=F_CPU/1000*periode/diviseur; // Calcul du pas<br />
TCNT1=0; // Compteur initialisé<br />
TIMSK1=(1<<OCIE1A); // Comparaison du compteur avec OCR1A<br />
}<br />
<br />
ISR(TIMER1_COMPA_vect/*, ISR_NAKED*/) // Procédure d'interruption<br />
{<br />
PORTB ^= (1 << PB5); <br />
}<br />
<br />
<br />
int main(void){<br />
DDRB |= (1 << PB5); <br />
init_minuteur(256,PERIODE);<br />
sei();<br />
while(1);<br />
}<br />
</syntaxhighlight><br />
<br />
==== Macros de sauvegarde et restauration des registres====<br />
<syntaxhighlight lang="c" line><br />
#define portSAVE_REGISTERS() \<br />
asm volatile ( \<br />
"push r0 \n\t" \<br />
"in r0, __SREG__ \n\t"\<br />
"cli \n\t" \<br />
"push r0 \n\t"\ <br />
"push r1 \n\t" \<br />
"clr r1 \n\t" \<br />
"push r2 \n\t"\<br />
"push r3 \n\t"\<br />
"push r4 \n\t"\<br />
"push r5 \n\t"\<br />
"push r6 \n\t"\<br />
"push r7 \n\t"\<br />
"push r8 \n\t"\<br />
"push r9 \n\t"\<br />
"push r10 \n\t"\<br />
"push r11 \n\t"\<br />
"push r12 \n\t"\<br />
"push r13 \n\t"\<br />
"push r14 \n\t"\<br />
"push r15 \n\t"\<br />
"push r16 \n\t"\<br />
"push r17 \n\t" \<br />
"push r18 \n\t"\<br />
"push r19 \n\t"\<br />
"push r20 \n\t" \<br />
"push r21 \n\t"\<br />
"push r22 \n\t"\<br />
"push r23 \n\t"\<br />
"push r24 \n\t"\<br />
"push r25 \n\t"\<br />
"push r26 \n\t"\<br />
"push r27 \n\t"\<br />
"push r28 \n\t"\<br />
"push r29 \n\t"\<br />
"push r30 \n\t"\<br />
"push r31 \n\t"\<br />
);<br />
<br />
#define portRESTORE_REGISTERS() \<br />
asm volatile (\<br />
"pop r31 \n\t" \<br />
"pop r30 \n\t"\<br />
"pop r29 \n\t" \<br />
"pop r28 \n\t" \<br />
"pop r27 \n\t" \<br />
"pop r26 \n\t" \<br />
"pop r25 \n\t"\<br />
"pop r24 \n\t" \<br />
"pop r23 \n\t" \<br />
"pop r22 \n\t" \<br />
"pop r21 \n\t" \<br />
"pop r20 \n\t" \<br />
"pop r19 \n\t" \<br />
"pop r18 \n\t" \<br />
"pop r17 \n\t" \<br />
"pop r16 \n\t" \<br />
"pop r15 \n\t" \<br />
"pop r14 \n\t" \<br />
"pop r13 \n\t" \<br />
"pop r12 \n\t" \<br />
"pop r11 \n\t" \<br />
"pop r10 \n\t"\<br />
"pop r9 \n\t" \<br />
"pop r8 \n\t" \<br />
"pop r7 \n\t" \<br />
"pop r6 \n\t" \<br />
"pop r5 \n\t" \<br />
"pop r4 \n\t" \<br />
"pop r3 \n\t" \<br />
"pop r2 \n\t" \<br />
"pop r1 \n\t" \<br />
"pop r0 \n\t" \<br />
"out __SREG__, r0 \n\t"\ <br />
"pop r0 \n\t" \<br />
);<br />
</syntaxhighlight><br />
<br />
====Coder le tableau des structures des processus====<br />
<syntaxhighlight lang="c" line><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
bool etat; //état du processus (1 ou 0)<br />
} Process;<br />
<br />
Process table_process[MAXPROCESS];<br />
</syntaxhighlight><br />
<br />
====Coder la fonction d'initialisation de la pile d'un processus====<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
<br />
====Taches ∞ pour faire clignoter deux leds à 2 fréquences premières entre elle====<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
[[Fichier:Ordonnanceur cligno led.mp4|vignette|thumb|center|700px|Clignotement des leds à des fréquences premières entre elle avec l'ordonnanceur]]<br />
<br />
====Lancement des deux tâches en parallèle grâce à l'ordonnanceur à tourniquet====<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6294SE4Binome2024-52024-10-15T13:44:15Z<p>Adjadjaa : /* Test de lecture de la carte SD */</p>
<hr />
<div>git : https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git<br />
<br />
Carte fille clavier "matrice de touches"<br />
=Hardware=<br />
<br />
== Carte Shield ==<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Shield après soudure des composants ==<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Fille ==<br />
<br />
== Carte Fille après soudure des composants ==<br />
<br />
= Software =<br />
== Carte Shield ==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Test de lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détectée et lue. On a utilisé le code test présent dans l'IDE arduino en adaptant le port utilisé.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/CardInfo<br />
<br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Ordonnanceur===<br />
==== Allumer la LED broche PB5 avec Timer1 ISR ====<br />
<br />
<br />
<syntaxhighlight lang="c" line><br />
#define CTC1 WGM12 // Meilleur nom pour le bit<br />
<br />
#define PERIODE 20<br />
<br />
void init_minuteur(int diviseur,long periode){<br />
TCCR1A=0; // Le mode choisi n'utilise pas ce registre<br />
TCCR1B=(1<<CTC1); // Réinitialisation du minuteur sur expiration<br />
switch(diviseur){<br />
case 8: TCCR1B |= (1<<CS11); break;<br />
case 64: TCCR1B |= (1<<CS11 | 11<<CS10); break;<br />
case 256: TCCR1B |= (1<<CS12); break;<br />
case 1024: TCCR1B |= (1<<CS12 | 1<<CS10); break;<br />
}<br />
// Un cycle prend 1/F_CPU secondes.<br />
// Un pas de compteur prend diviseur/F_CPU secondes.<br />
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas<br />
// soit (periode*F_CPU)/(1000*diviseur)<br />
OCR1A=F_CPU/1000*periode/diviseur; // Calcul du pas<br />
TCNT1=0; // Compteur initialisé<br />
TIMSK1=(1<<OCIE1A); // Comparaison du compteur avec OCR1A<br />
}<br />
<br />
ISR(TIMER1_COMPA_vect/*, ISR_NAKED*/) // Procédure d'interruption<br />
{<br />
PORTB ^= (1 << PB5); <br />
}<br />
<br />
<br />
int main(void){<br />
DDRB |= (1 << PB5); <br />
init_minuteur(256,PERIODE);<br />
sei();<br />
while(1);<br />
}<br />
</syntaxhighlight><br />
<br />
==== Macros de sauvegarde et restauration des registres====<br />
<syntaxhighlight lang="c" line><br />
#define portSAVE_REGISTERS() \<br />
asm volatile ( \<br />
"push r0 \n\t" \<br />
"in r0, __SREG__ \n\t"\<br />
"cli \n\t" \<br />
"push r0 \n\t"\ <br />
"push r1 \n\t" \<br />
"clr r1 \n\t" \<br />
"push r2 \n\t"\<br />
"push r3 \n\t"\<br />
"push r4 \n\t"\<br />
"push r5 \n\t"\<br />
"push r6 \n\t"\<br />
"push r7 \n\t"\<br />
"push r8 \n\t"\<br />
"push r9 \n\t"\<br />
"push r10 \n\t"\<br />
"push r11 \n\t"\<br />
"push r12 \n\t"\<br />
"push r13 \n\t"\<br />
"push r14 \n\t"\<br />
"push r15 \n\t"\<br />
"push r16 \n\t"\<br />
"push r17 \n\t" \<br />
"push r18 \n\t"\<br />
"push r19 \n\t"\<br />
"push r20 \n\t" \<br />
"push r21 \n\t"\<br />
"push r22 \n\t"\<br />
"push r23 \n\t"\<br />
"push r24 \n\t"\<br />
"push r25 \n\t"\<br />
"push r26 \n\t"\<br />
"push r27 \n\t"\<br />
"push r28 \n\t"\<br />
"push r29 \n\t"\<br />
"push r30 \n\t"\<br />
"push r31 \n\t"\<br />
);<br />
<br />
#define portRESTORE_REGISTERS() \<br />
asm volatile (\<br />
"pop r31 \n\t" \<br />
"pop r30 \n\t"\<br />
"pop r29 \n\t" \<br />
"pop r28 \n\t" \<br />
"pop r27 \n\t" \<br />
"pop r26 \n\t" \<br />
"pop r25 \n\t"\<br />
"pop r24 \n\t" \<br />
"pop r23 \n\t" \<br />
"pop r22 \n\t" \<br />
"pop r21 \n\t" \<br />
"pop r20 \n\t" \<br />
"pop r19 \n\t" \<br />
"pop r18 \n\t" \<br />
"pop r17 \n\t" \<br />
"pop r16 \n\t" \<br />
"pop r15 \n\t" \<br />
"pop r14 \n\t" \<br />
"pop r13 \n\t" \<br />
"pop r12 \n\t" \<br />
"pop r11 \n\t" \<br />
"pop r10 \n\t"\<br />
"pop r9 \n\t" \<br />
"pop r8 \n\t" \<br />
"pop r7 \n\t" \<br />
"pop r6 \n\t" \<br />
"pop r5 \n\t" \<br />
"pop r4 \n\t" \<br />
"pop r3 \n\t" \<br />
"pop r2 \n\t" \<br />
"pop r1 \n\t" \<br />
"pop r0 \n\t" \<br />
"out __SREG__, r0 \n\t"\ <br />
"pop r0 \n\t" \<br />
);<br />
</syntaxhighlight><br />
<br />
====Coder le tableau des structures des processus====<br />
<syntaxhighlight lang="c" line><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
bool etat; //état du processus (1 ou 0)<br />
} Process;<br />
<br />
Process table_process[MAXPROCESS];<br />
</syntaxhighlight><br />
<br />
====Coder la fonction d'initialisation de la pile d'un processus====<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
<br />
====Taches ∞ pour faire clignoter deux leds à 2 fréquences premières entre elle====<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
[[Fichier:Ordonnanceur cligno led.mp4|vignette|thumb|center|700px|Clignotement des leds à des fréquences premières entre elle avec l'ordonnanceur]]<br />
<br />
====Lancement des deux tâches en parallèle grâce à l'ordonnanceur à tourniquet====<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight></div>Adjadjaahttps://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-5&diff=6293SE4Binome2024-52024-10-15T13:42:48Z<p>Adjadjaa : /* Allumage de LEDS sur Programmateur AVR */</p>
<hr />
<div>git : https://gitea.plil.fr/ktouron/se4-djadja-touron_pico.git<br />
<br />
Carte fille clavier "matrice de touches"<br />
=Hardware=<br />
<br />
== Carte Shield ==<br />
[[Fichier:Carte Recto non soudé.jpg|vignette|left|thumb|350px|Recto de la carte avant soudage des composants]]<br />
[[Fichier:Verso non solder.jpeg.jpg|vignette|thumb|right|350px|Verso de la carte avant soudage des composants]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Shield après soudure des composants ==<br />
[[Fichier:Carde shield soudé.jpg|vignette|thumb|center|400px|Photo de la carte avec les composants soudés]]<br />
<br style="clear: both;" /><br />
<br />
== Carte Fille ==<br />
<br />
== Carte Fille après soudure des composants ==<br />
<br />
= Software =<br />
== Carte Shield ==<br />
=== Allumage de LEDS sur Programmateur AVR ===<br />
Avant de programmer directement sur le shield, nous avons allumé des LED pour tester la carte. Nous avons directement utilisé le code exemple fourni par l'IDE arduino en adaptant simplement les pins correspondant aux leds.<br />
<br />
https://gitea.plil.fr/ktouron/se4-djadja-touron_pico/src/branch/main/PicoShield/Programmation/Blink<br />
<br />
[[Fichier:Vid_test_carte_mp4.mp4|vignette|thumb|center|700px|Vidéo de Test des leds]]<br />
<br />
=== Test de lecture de la carte SD ===<br />
Avant de programmer directement sur le shield, nous avons tester si la carte SD était bien détecté et lu<br />
<syntaxhighlight lang="c" line><br />
#include <SPI.h><br />
#include <SD.h><br />
<br />
Sd2Card card;<br />
SdVolume volume;<br />
SdFile root;<br />
<br />
const int chipSelect = 10;<br />
<br />
void setup() {<br />
// Open serial communications and wait for port to open:<br />
Serial.begin(9600);<br />
while (!Serial) {<br />
; // wait for serial port to connect. Needed for native USB port only<br />
}<br />
<br />
<br />
Serial.print("\nInitializing SD card...");<br />
<br />
// we'll use the initialization code from the utility libraries<br />
// since we're just testing if the card is working!<br />
if (!card.init(SPI_HALF_SPEED, chipSelect)) {<br />
Serial.println("initialization failed. Things to check:");<br />
Serial.println("* is a card inserted?");<br />
Serial.println("* is your wiring correct?");<br />
Serial.println("* did you change the chipSelect pin to match your shield or module?");<br />
while (1);<br />
} else {<br />
Serial.println("Wiring is correct and a card is present.");<br />
}<br />
<br />
// print the type of card<br />
Serial.println();<br />
Serial.print("Card type: ");<br />
switch (card.type()) {<br />
case SD_CARD_TYPE_SD1:<br />
Serial.println("SD1");<br />
break;<br />
case SD_CARD_TYPE_SD2:<br />
Serial.println("SD2");<br />
break;<br />
case SD_CARD_TYPE_SDHC:<br />
Serial.println("SDHC");<br />
break;<br />
default:<br />
Serial.println("Unknown");<br />
}<br />
<br />
// Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32<br />
if (!volume.init(card)) {<br />
Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");<br />
while (1);<br />
}<br />
<br />
Serial.print("Clusters: ");<br />
Serial.println(volume.clusterCount());<br />
Serial.print("Blocks x Cluster: ");<br />
Serial.println(volume.blocksPerCluster());<br />
<br />
Serial.print("Total Blocks: ");<br />
Serial.println(volume.blocksPerCluster() * volume.clusterCount());<br />
Serial.println();<br />
<br />
// print the type and size of the first FAT-type volume<br />
uint32_t volumesize;<br />
Serial.print("Volume type is: FAT");<br />
Serial.println(volume.fatType(), DEC);<br />
<br />
volumesize = volume.blocksPerCluster(); // clusters are collections of blocks<br />
volumesize *= volume.clusterCount(); // we'll have a lot of clusters<br />
volumesize /= 2; // SD card blocks are always 512 bytes (2 blocks are 1KB)<br />
Serial.print("Volume size (Kb): ");<br />
Serial.println(volumesize);<br />
Serial.print("Volume size (Mb): ");<br />
volumesize /= 1024;<br />
Serial.println(volumesize);<br />
Serial.print("Volume size (Gb): ");<br />
Serial.println((float)volumesize / 1024.0);<br />
<br />
Serial.println("\nFiles found on the card (name, date and size in bytes): ");<br />
root.openRoot(volume);<br />
<br />
// list all files in the card with date and size<br />
root.ls(LS_R | LS_DATE | LS_SIZE);<br />
}<br />
<br />
void loop(void) {<br />
}<br />
</syntaxhighlight><br />
[[Fichier:Resultat SD.jpg|vignette|thumb|center|700px|Carte SD bien détéctée]]<br />
<br />
=== Ordonnanceur===<br />
==== Allumer la LED broche PB5 avec Timer1 ISR ====<br />
<br />
<br />
<syntaxhighlight lang="c" line><br />
#define CTC1 WGM12 // Meilleur nom pour le bit<br />
<br />
#define PERIODE 20<br />
<br />
void init_minuteur(int diviseur,long periode){<br />
TCCR1A=0; // Le mode choisi n'utilise pas ce registre<br />
TCCR1B=(1<<CTC1); // Réinitialisation du minuteur sur expiration<br />
switch(diviseur){<br />
case 8: TCCR1B |= (1<<CS11); break;<br />
case 64: TCCR1B |= (1<<CS11 | 11<<CS10); break;<br />
case 256: TCCR1B |= (1<<CS12); break;<br />
case 1024: TCCR1B |= (1<<CS12 | 1<<CS10); break;<br />
}<br />
// Un cycle prend 1/F_CPU secondes.<br />
// Un pas de compteur prend diviseur/F_CPU secondes.<br />
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas<br />
// soit (periode*F_CPU)/(1000*diviseur)<br />
OCR1A=F_CPU/1000*periode/diviseur; // Calcul du pas<br />
TCNT1=0; // Compteur initialisé<br />
TIMSK1=(1<<OCIE1A); // Comparaison du compteur avec OCR1A<br />
}<br />
<br />
ISR(TIMER1_COMPA_vect/*, ISR_NAKED*/) // Procédure d'interruption<br />
{<br />
PORTB ^= (1 << PB5); <br />
}<br />
<br />
<br />
int main(void){<br />
DDRB |= (1 << PB5); <br />
init_minuteur(256,PERIODE);<br />
sei();<br />
while(1);<br />
}<br />
</syntaxhighlight><br />
<br />
==== Macros de sauvegarde et restauration des registres====<br />
<syntaxhighlight lang="c" line><br />
#define portSAVE_REGISTERS() \<br />
asm volatile ( \<br />
"push r0 \n\t" \<br />
"in r0, __SREG__ \n\t"\<br />
"cli \n\t" \<br />
"push r0 \n\t"\ <br />
"push r1 \n\t" \<br />
"clr r1 \n\t" \<br />
"push r2 \n\t"\<br />
"push r3 \n\t"\<br />
"push r4 \n\t"\<br />
"push r5 \n\t"\<br />
"push r6 \n\t"\<br />
"push r7 \n\t"\<br />
"push r8 \n\t"\<br />
"push r9 \n\t"\<br />
"push r10 \n\t"\<br />
"push r11 \n\t"\<br />
"push r12 \n\t"\<br />
"push r13 \n\t"\<br />
"push r14 \n\t"\<br />
"push r15 \n\t"\<br />
"push r16 \n\t"\<br />
"push r17 \n\t" \<br />
"push r18 \n\t"\<br />
"push r19 \n\t"\<br />
"push r20 \n\t" \<br />
"push r21 \n\t"\<br />
"push r22 \n\t"\<br />
"push r23 \n\t"\<br />
"push r24 \n\t"\<br />
"push r25 \n\t"\<br />
"push r26 \n\t"\<br />
"push r27 \n\t"\<br />
"push r28 \n\t"\<br />
"push r29 \n\t"\<br />
"push r30 \n\t"\<br />
"push r31 \n\t"\<br />
);<br />
<br />
#define portRESTORE_REGISTERS() \<br />
asm volatile (\<br />
"pop r31 \n\t" \<br />
"pop r30 \n\t"\<br />
"pop r29 \n\t" \<br />
"pop r28 \n\t" \<br />
"pop r27 \n\t" \<br />
"pop r26 \n\t" \<br />
"pop r25 \n\t"\<br />
"pop r24 \n\t" \<br />
"pop r23 \n\t" \<br />
"pop r22 \n\t" \<br />
"pop r21 \n\t" \<br />
"pop r20 \n\t" \<br />
"pop r19 \n\t" \<br />
"pop r18 \n\t" \<br />
"pop r17 \n\t" \<br />
"pop r16 \n\t" \<br />
"pop r15 \n\t" \<br />
"pop r14 \n\t" \<br />
"pop r13 \n\t" \<br />
"pop r12 \n\t" \<br />
"pop r11 \n\t" \<br />
"pop r10 \n\t"\<br />
"pop r9 \n\t" \<br />
"pop r8 \n\t" \<br />
"pop r7 \n\t" \<br />
"pop r6 \n\t" \<br />
"pop r5 \n\t" \<br />
"pop r4 \n\t" \<br />
"pop r3 \n\t" \<br />
"pop r2 \n\t" \<br />
"pop r1 \n\t" \<br />
"pop r0 \n\t" \<br />
"out __SREG__, r0 \n\t"\ <br />
"pop r0 \n\t" \<br />
);<br />
</syntaxhighlight><br />
<br />
====Coder le tableau des structures des processus====<br />
<syntaxhighlight lang="c" line><br />
typedef struct {<br />
uint16_t adresseDepart; //adresse de la fonction de départ <br />
uint16_t adressePile; //adresse de la pile d'exécution<br />
bool etat; //état du processus (1 ou 0)<br />
} Process;<br />
<br />
Process table_process[MAXPROCESS];<br />
</syntaxhighlight><br />
<br />
====Coder la fonction d'initialisation de la pile d'un processus====<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
<br />
====Taches ∞ pour faire clignoter deux leds à 2 fréquences premières entre elle====<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight><br />
[[Fichier:Ordonnanceur cligno led.mp4|vignette|thumb|center|700px|Clignotement des leds à des fréquences premières entre elle avec l'ordonnanceur]]<br />
<br />
====Lancement des deux tâches en parallèle grâce à l'ordonnanceur à tourniquet====<br />
<syntaxhighlight lang="c" line><br />
A REMPLIR<br />
</syntaxhighlight></div>Adjadjaa