https://projets-se.plil.fr/mediawiki/api.php?action=feedcontributions&feedformat=atom&user=Alecomt1projets-se.plil.fr - Contributions [fr]2026-05-14T03:43:04ZContributionsMediaWiki 1.39.1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=7223SE4Binome2024-82025-01-21T12:46:37Z<p>Alecomt1 : /* Conclusion */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===Modification Shield===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de notre shield]]<br />
<br />
<br style="clear: both;" /><br />
===Assemblage et test du Shield===<br />
<br />
Nous avons soudé les composants sur le shield puis testé les leds et un afficheur 7 segments connecté (en ISP) sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===Test de la carte SD===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry Pi par exemple et d'obtenir jusqu'à 15w ce qui est largement suffisant pour notre carte mère et les cartes filles des autres binômes.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|469x469px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|588x588px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|412x412px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
[[File:Pico2024_B8_erreur.png|thumb|left|364x364px|D- et D+ inversés]]Nous installons maintenant le firmware dans le 8u2 et le bootloader dans le 328p afin de pouvoir programmer le 328p en utilisant la connexion USB du 8u2. <br>Pour cela il faut d'abord effacer le 8u2 avec les commandes suivantes : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t</code>, Il faut ensuite envoyer la commande <code>erase</code> et <code>quit</code> <br><br />
On peux maintenant modifier les fuses pour notre crystal externe à 16MHz : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xde:m -U hfuse:w:0xd9:m -U efuse:w:0xf4:m</code><br>Puis flasher le firmware 8u2 provenant d'une Arduino UNO : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:8u2_firmware.hex</code><br><br />
Pour la programmation du Bootloader du 328p on utilise directement la fonction "burn bootloader" de l'IDE Arduino. <br />
<br />
Malheureusement notre carte n'est pas reconnue par l'ordinateur avec la commande <code>lsusb</code>. Avec <code>dmesg</code> nous voyons qu'un périphérique USB est détecté mais avec des erreurs, nous essayons de ressouder notre connecteur USB-C à l'air chaud et vérifions au multimètre que les pins sont bien soudés mais nous avons toujours les mêmes erreurs. Après vérification de notre schéma une erreur s'est glissée lors du commit 181625dc05 fait par monsieur Redon, les pins D+ et D- sont inversés. Nous modifions notre carte pour corriger cette inversion. Succès !! notre carte est maintenant bien visible en USB. [[File:Pico2024_B8_lsusb.png|thumb|right|500px|Reconnue (comme une Arduino UNO)]]<br />
<br />
<br />
Après soudure des connecteurs HE10, des leds et de leurs résistances correspondantes, nous avons téleversé notre code pour l'ordonnanceur. Les leds clignotent bien et l'écran 7 segments connecté à la PicoMother fonctionne parfaitement et simultanément.[[File:Pico2024_B8_mother_soudee.png|thumb|left|500px|Carte soudée]]<br />
[[File:Pico2024_B8_mother_ordonnanceur.mp4|thumb|right|500px|Ordonnanceur sur notre carte]]<br />
<br />
Nous testons également que la carte SD est détectable par notre carte mère et c'est bien le cas.<br />
<br style="clear: both;" /><br />
<br />
=Système de fichier=<br />
<br />
[[File:Pico2024_secteur0.jpg|thumb|right|500px|Le contenu du secteur 0]]<br />
Nous passons maintenant à la dernière partie du projet, le système de fichiers. Pour cela nous commençons par essayer de lire et d'écrire un secteur de la carte SD (en mode SPI une carte SD et accessible par blocs (secteurs) de 512 octets), nous utilisons la bibliothèque suivante pour faciliter la gestion de la carte SD :[https://github.com/ryanj1234/SD_TUTORIAL_PART4 Bibliothèque SD]. En modifiant cette bibliothèque on arrive à lire et écrire un secteur de la carte SD. Sur cette photo on lit le secteur 0 de la carte SD, 0x55AA à la fin du secteur signifie que la carte est actuellement formatée avec un système de fichier MBR.<br />
<br />
Après avoir confirmé que nous pouvons lire le bloc 0 nous avons essayé de lire les blocs suivants, or nous obtenions une erreur <code>Address out of range</code>. Le problème vient du fait qu'on utilise une carte SD standard (pas SDHC) et qu'il faut multiplier le numéro de bloc par 512. En effet les cartes SDHC et SDXC sont block-addressed, le bloc 0 est à l'adresse 0, le bloc 1 à l'adresse 1 mais les cartes SD (comme la notre) sont bytes-addressed, le bloc 0 est à l'adresse 0, le bloc 1 à l'adresse 512... Nous avons donc créé une fonction intermédiaire qui multiplie le numero de bloc voulu par 512 (décalage de 9 bits) pour obtenir l'adresse du bloc. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void lecture_block(uint32_t block){<br />
uint8_t res, token;<br />
uint32_t addr = block << 9; //Multiplication par 512<br />
// Lecture du bloc (secteur)<br />
res = SD_readSingleBlock(addr, buffer, &token); //res reçoit un octet décrivant l'état de la carte SD (pas utilisé dans notre code)<br />
// Impression en cas d'erreur<br />
if(!(token & 0xF0)){<br />
UART_pputs("Erreur :\r\n");<br />
SD_printDataErrToken(token);<br />
}<br />
}<br />
</syntaxhighlight><br />
Comme on ne peut lire ou écrire qu'un bloc complet, nous avons implémenté un buffer d'une taille de 512 octets que l'on modifie puis écris dans un bloc de la carte SD ou qui reçoit un bloc complet de celle-ci, ce buffer utilise un quart de la mémoire vive de notre atmega (2ko sur un atmega328p). <br />
<br style="clear: both;" /><br />
<br />
Une fois les fonctions de lecture et d'écriture de blocs sur la carte SD adaptées à notre carte mère et carte SD nous avons commencé à créer notre pico système de fichiers.<br />
<br style="clear: both;" /><br />
[[File:Pico2024_B8_schema_sysfich.png|thumb|center|800px|Schéma de notre système de fichiers]]<br />
<br style="clear: both;" /> <br />
Nous avons utilisé deux blocs de la carte comme superblocs (table of content) qui contiennent des "descripteurs" de fichiers et pointent vers le premier bloc au sont stockées les données (4 blocs consécutifs). Nous avons choisi de que nos fichiers doivent avoir un nom de 14 caractères maximum, ainsi notre structure Fichier à une taille de 16 octets et on peut en mettre 32 par superbloc (32*16 = 512), deux superblocs suffiront donc pour accéder à 64 fichiers. En tout notre système de fichiers utilise 132096 octets sur la carte SD (4*64*512 + 2*512).<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
struct Fichier{<br />
uint8_t available;<br />
uint8_t starting_block;<br />
char name[FILE_NAME];<br />
}typedef Fichier; //Taille 16 octets<br />
</syntaxhighlight><br />
<br />
Nous avons donc commencé par implémenter la fonction format qui efface tout les blocs de données et rempli les superblocs de structures Fichier disponibles, avec le starting_block adéquat et un nom vide.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void FORMAT(){<br />
UART_pputs("Formatage...\r\n");<br />
//On rempli le buffer de 0x00<br />
clear_buffer();<br />
for(int i = 0; i < TOC_BLOCKS + (BLOCK_PAR_FILE * MAX_FILE); i++){<br />
ecriture_block(i); //on remplit tous les blocs de données et la TOC avec les 0x00<br />
}<br />
Fichier fichier; //Création d'une struct Fichier<br />
fichier.available = 0x01; //Le fichier est disponible <br />
memset(fichier.name, 0x00, FILE_NAME); //nom vide (charactere 00 en hex)<br />
//On écrit la TOC dans le buffer (on place des structs Fichier avec available -> 0x01)<br />
for (int toc = 0; toc < TOC_BLOCKS; toc++) {<br />
for (int j = 0; j < MAX_FILE; j++) {<br />
fichier.starting_block = TOC_BLOCKS + (j * BLOCK_PAR_FILE) + (toc * FILE_PAR_TOC);<br />
int start_index = j * sizeof(Fichier);<br />
memcpy(&buffer[start_index], &fichier, sizeof(Fichier)); // Copie de la structure<br />
}<br />
ecriture_block(toc); // Écriture du buffer dans le superbloc correspondant<br />
}<br />
UART_pputs("Formatage terminé\r\n");<br />
}<br />
</syntaxhighlight><br />
<br />
Pour la commande LS() on parcours les deux superblocs et on envoie sur le port série le noms des fichiers présents sur la carte SD.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void LS(){<br />
UART_pputs("Fichier(s) sur la carte SD :\r\n");<br />
for (int toc = 0; toc < TOC_BLOCKS; toc++){ // On boucle sur les differents blocs de TOC<br />
lecture_block(toc);<br />
for (int i = 0; i < FILE_PAR_TOC; i++){<br />
// Création d'un struct fichier<br />
Fichier fichier;<br />
// On rempli Fichier avec les infos du buffer<br />
memcpy(&fichier, &buffer[i * sizeof(Fichier)], sizeof(Fichier));<br />
// Fichier non dispo donc un fichier est stocké sur la carte<br />
if (fichier.available == 0x00) {<br />
UART_puts(fichier.name); //Affichage du nom du fichier trouvé<br />
UART_pputs("\r\n");<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Nous avons ensuite implémenté les fonctions suivantes:<br />
* APPEND() : crée un fichier sur la carte SD, si il existe déjà les données passées en paramètre sont ajoutées à la fin du fichier existant<br />
* READ() : renvoie sur le port série le contenu du fichier demandé<br />
* REMOVE() : supprime le fichier demandé, on "vide" son descripteur dans le superbloc puis on rempli les 4 blocs de données de 0x00<br />
* RENAME() : permet de renommer un fichier, on remplace simplement sont nom dans son descripteur (pas de modification des blocs de données)<br />
* COPY() : copie d'un fichier source vers un nouveau fichier destination<br />
<br />
Toutes ces fonctions et les fonctions intermédiaires sont dans le fichier <code>SysFich/sys_fichier.c</code> dans notre dépot GIT.<br />
<br />
Pour finir nous avons créé une interface en série pour envoyer les commandes à la carte mère et recevoir le contenu des fichiers. <br />
[[File:Pico2024_B8_sysfich.mp4|thumb|center|800px|Utilisation de notre système de fichiers]]<br />
<br style="clear: both;" /><br />
<br />
Sur la vidéo on peut bien constater que la carte SD crée bien les fichiers comme on le demande, on arrive à les lire (<code>63 6F 75 63 6F 75 20 63 27 65 73 74 20 6C 6F 75 69 73</code> en hexa donne bien le message <code>coucou c'est louis</code>), à concaténer du texte à la fin d'un fichier, de regarder les différents fichiers, de les copier et également les supprimer à volonté.<br />
<br />
=Conclusion=<br />
<br />
<br />
Ce projet était très intéressant et très complet sur beaucoup d'aspect différent de la formation, que ce soit pour la conception de la carte, la partie programmation avec l'ordonnanceur et la partie système de fichiers. Mais bien que le commencement fut très satisfaisant et que notre progression était plutôt rapide pour un projet de cette envergure, nous avons eu pas mal de soucis pour la partie gestion des fichiers sur la carte SD. Que ce soit les recherches pour comprendre le fonctionnement de la mémoire d'une carte SD ou encore réussir à communiquer avec par SPI, notre avancement fut fortement ralenti pendant plusieurs séances. Nous n'avons malheureusement pas pu finir ce projet totalement, nous aurions par la suite dû gérer les connexions des différentes cartes filles. C'est à dire que celles-ci puissent utiliser le système de fichiers pour pouvoir enregistrer et lire sur la carte SD (envoie de commandes par SPI plutôt que UART).</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=7222SE4Binome2024-82025-01-21T12:35:04Z<p>Alecomt1 : /* Système de fichier */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===Modification Shield===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de notre shield]]<br />
<br />
<br style="clear: both;" /><br />
===Assemblage et test du Shield===<br />
<br />
Nous avons soudé les composants sur le shield puis testé les leds et un afficheur 7 segments connecté (en ISP) sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===Test de la carte SD===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry Pi par exemple et d'obtenir jusqu'à 15w ce qui est largement suffisant pour notre carte mère et les cartes filles des autres binômes.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|469x469px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|588x588px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|412x412px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
[[File:Pico2024_B8_erreur.png|thumb|left|364x364px|D- et D+ inversés]]Nous installons maintenant le firmware dans le 8u2 et le bootloader dans le 328p afin de pouvoir programmer le 328p en utilisant la connexion USB du 8u2. <br>Pour cela il faut d'abord effacer le 8u2 avec les commandes suivantes : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t</code>, Il faut ensuite envoyer la commande <code>erase</code> et <code>quit</code> <br><br />
On peux maintenant modifier les fuses pour notre crystal externe à 16MHz : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xde:m -U hfuse:w:0xd9:m -U efuse:w:0xf4:m</code><br>Puis flasher le firmware 8u2 provenant d'une Arduino UNO : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:8u2_firmware.hex</code><br><br />
Pour la programmation du Bootloader du 328p on utilise directement la fonction "burn bootloader" de l'IDE Arduino. <br />
<br />
Malheureusement notre carte n'est pas reconnue par l'ordinateur avec la commande <code>lsusb</code>. Avec <code>dmesg</code> nous voyons qu'un périphérique USB est détecté mais avec des erreurs, nous essayons de ressouder notre connecteur USB-C à l'air chaud et vérifions au multimètre que les pins sont bien soudés mais nous avons toujours les mêmes erreurs. Après vérification de notre schéma une erreur s'est glissée lors du commit 181625dc05 fait par monsieur Redon, les pins D+ et D- sont inversés. Nous modifions notre carte pour corriger cette inversion. Succès !! notre carte est maintenant bien visible en USB. [[File:Pico2024_B8_lsusb.png|thumb|right|500px|Reconnue (comme une Arduino UNO)]]<br />
<br />
<br />
Après soudure des connecteurs HE10, des leds et de leurs résistances correspondantes, nous avons téleversé notre code pour l'ordonnanceur. Les leds clignotent bien et l'écran 7 segments connecté à la PicoMother fonctionne parfaitement et simultanément.[[File:Pico2024_B8_mother_soudee.png|thumb|left|500px|Carte soudée]]<br />
[[File:Pico2024_B8_mother_ordonnanceur.mp4|thumb|right|500px|Ordonnanceur sur notre carte]]<br />
<br />
Nous testons également que la carte SD est détectable par notre carte mère et c'est bien le cas.<br />
<br style="clear: both;" /><br />
<br />
=Système de fichier=<br />
<br />
[[File:Pico2024_secteur0.jpg|thumb|right|500px|Le contenu du secteur 0]]<br />
Nous passons maintenant à la dernière partie du projet, le système de fichiers. Pour cela nous commençons par essayer de lire et d'écrire un secteur de la carte SD (en mode SPI une carte SD et accessible par blocs (secteurs) de 512 octets), nous utilisons la bibliothèque suivante pour faciliter la gestion de la carte SD :[https://github.com/ryanj1234/SD_TUTORIAL_PART4 Bibliothèque SD]. En modifiant cette bibliothèque on arrive à lire et écrire un secteur de la carte SD. Sur cette photo on lit le secteur 0 de la carte SD, 0x55AA à la fin du secteur signifie que la carte est actuellement formatée avec un système de fichier MBR.<br />
<br />
Après avoir confirmé que nous pouvons lire le bloc 0 nous avons essayé de lire les blocs suivants, or nous obtenions une erreur <code>Address out of range</code>. Le problème vient du fait qu'on utilise une carte SD standard (pas SDHC) et qu'il faut multiplier le numéro de bloc par 512. En effet les cartes SDHC et SDXC sont block-addressed, le bloc 0 est à l'adresse 0, le bloc 1 à l'adresse 1 mais les cartes SD (comme la notre) sont bytes-addressed, le bloc 0 est à l'adresse 0, le bloc 1 à l'adresse 512... Nous avons donc créé une fonction intermédiaire qui multiplie le numero de bloc voulu par 512 (décalage de 9 bits) pour obtenir l'adresse du bloc. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void lecture_block(uint32_t block){<br />
uint8_t res, token;<br />
uint32_t addr = block << 9; //Multiplication par 512<br />
// Lecture du bloc (secteur)<br />
res = SD_readSingleBlock(addr, buffer, &token); //res reçoit un octet décrivant l'état de la carte SD (pas utilisé dans notre code)<br />
// Impression en cas d'erreur<br />
if(!(token & 0xF0)){<br />
UART_pputs("Erreur :\r\n");<br />
SD_printDataErrToken(token);<br />
}<br />
}<br />
</syntaxhighlight><br />
Comme on ne peut lire ou écrire qu'un bloc complet, nous avons implémenté un buffer d'une taille de 512 octets que l'on modifie puis écris dans un bloc de la carte SD ou qui reçoit un bloc complet de celle-ci, ce buffer utilise un quart de la mémoire vive de notre atmega (2ko sur un atmega328p). <br />
<br style="clear: both;" /><br />
<br />
Une fois les fonctions de lecture et d'écriture de blocs sur la carte SD adaptées à notre carte mère et carte SD nous avons commencé à créer notre pico système de fichiers.<br />
<br style="clear: both;" /><br />
[[File:Pico2024_B8_schema_sysfich.png|thumb|center|800px|Schéma de notre système de fichiers]]<br />
<br style="clear: both;" /> <br />
Nous avons utilisé deux blocs de la carte comme superblocs (table of content) qui contiennent des "descripteurs" de fichiers et pointent vers le premier bloc au sont stockées les données (4 blocs consécutifs). Nous avons choisi de que nos fichiers doivent avoir un nom de 14 caractères maximum, ainsi notre structure Fichier à une taille de 16 octets et on peut en mettre 32 par superbloc (32*16 = 512), deux superblocs suffiront donc pour accéder à 64 fichiers. En tout notre système de fichiers utilise 132096 octets sur la carte SD (4*64*512 + 2*512).<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
struct Fichier{<br />
uint8_t available;<br />
uint8_t starting_block;<br />
char name[FILE_NAME];<br />
}typedef Fichier; //Taille 16 octets<br />
</syntaxhighlight><br />
<br />
Nous avons donc commencé par implémenter la fonction format qui efface tout les blocs de données et rempli les superblocs de structures Fichier disponibles, avec le starting_block adéquat et un nom vide.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void FORMAT(){<br />
UART_pputs("Formatage...\r\n");<br />
//On rempli le buffer de 0x00<br />
clear_buffer();<br />
for(int i = 0; i < TOC_BLOCKS + (BLOCK_PAR_FILE * MAX_FILE); i++){<br />
ecriture_block(i); //on remplit tous les blocs de données et la TOC avec les 0x00<br />
}<br />
Fichier fichier; //Création d'une struct Fichier<br />
fichier.available = 0x01; //Le fichier est disponible <br />
memset(fichier.name, 0x00, FILE_NAME); //nom vide (charactere 00 en hex)<br />
//On écrit la TOC dans le buffer (on place des structs Fichier avec available -> 0x01)<br />
for (int toc = 0; toc < TOC_BLOCKS; toc++) {<br />
for (int j = 0; j < MAX_FILE; j++) {<br />
fichier.starting_block = TOC_BLOCKS + (j * BLOCK_PAR_FILE) + (toc * FILE_PAR_TOC);<br />
int start_index = j * sizeof(Fichier);<br />
memcpy(&buffer[start_index], &fichier, sizeof(Fichier)); // Copie de la structure<br />
}<br />
ecriture_block(toc); // Écriture du buffer dans le superbloc correspondant<br />
}<br />
UART_pputs("Formatage terminé\r\n");<br />
}<br />
</syntaxhighlight><br />
<br />
Pour la commande LS() on parcours les deux superblocs et on envoie sur le port série le noms des fichiers présents sur la carte SD.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void LS(){<br />
UART_pputs("Fichier(s) sur la carte SD :\r\n");<br />
for (int toc = 0; toc < TOC_BLOCKS; toc++){ // On boucle sur les differents blocs de TOC<br />
lecture_block(toc);<br />
for (int i = 0; i < FILE_PAR_TOC; i++){<br />
// Création d'un struct fichier<br />
Fichier fichier;<br />
// On rempli Fichier avec les infos du buffer<br />
memcpy(&fichier, &buffer[i * sizeof(Fichier)], sizeof(Fichier));<br />
// Fichier non dispo donc un fichier est stocké sur la carte<br />
if (fichier.available == 0x00) {<br />
UART_puts(fichier.name); //Affichage du nom du fichier trouvé<br />
UART_pputs("\r\n");<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Nous avons ensuite implémenté les fonctions suivantes:<br />
* APPEND() : crée un fichier sur la carte SD, si il existe déjà les données passées en paramètre sont ajoutées à la fin du fichier existant<br />
* READ() : renvoie sur le port série le contenu du fichier demandé<br />
* REMOVE() : supprime le fichier demandé, on "vide" son descripteur dans le superbloc puis on rempli les 4 blocs de données de 0x00<br />
* RENAME() : permet de renommer un fichier, on remplace simplement sont nom dans son descripteur (pas de modification des blocs de données)<br />
* COPY() : copie d'un fichier source vers un nouveau fichier destination<br />
<br />
Toutes ces fonctions et les fonctions intermédiaires sont dans le fichier <code>SysFich/sys_fichier.c</code> dans notre dépot GIT.<br />
<br />
Pour finir nous avons créé une interface en série pour envoyer les commandes à la carte mère et recevoir le contenu des fichiers. <br />
[[File:Pico2024_B8_sysfich.mp4|thumb|center|800px|Utilisation de notre système de fichiers]]<br />
<br style="clear: both;" /><br />
<br />
Sur la vidéo on peut bien constater que la carte SD crée bien les fichiers comme on le demande, on arrive à les lire (<code>63 6F 75 63 6F 75 20 63 27 65 73 74 20 6C 6F 75 69 73</code> en hexa donne bien le message <code>coucou c'est louis</code>), à concaténer du texte à la fin d'un fichier, de regarder les différents fichiers, de les copier et également les supprimer à volonté.<br />
<br />
=Conclusion=</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=7221SE4Binome2024-82025-01-21T12:29:11Z<p>Alecomt1 : /* Système de fichier */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===Modification Shield===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de notre shield]]<br />
<br />
<br style="clear: both;" /><br />
===Assemblage et test du Shield===<br />
<br />
Nous avons soudé les composants sur le shield puis testé les leds et un afficheur 7 segments connecté (en ISP) sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===Test de la carte SD===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry Pi par exemple et d'obtenir jusqu'à 15w ce qui est largement suffisant pour notre carte mère et les cartes filles des autres binômes.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|469x469px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|588x588px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|412x412px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
[[File:Pico2024_B8_erreur.png|thumb|left|364x364px|D- et D+ inversés]]Nous installons maintenant le firmware dans le 8u2 et le bootloader dans le 328p afin de pouvoir programmer le 328p en utilisant la connexion USB du 8u2. <br>Pour cela il faut d'abord effacer le 8u2 avec les commandes suivantes : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t</code>, Il faut ensuite envoyer la commande <code>erase</code> et <code>quit</code> <br><br />
On peux maintenant modifier les fuses pour notre crystal externe à 16MHz : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xde:m -U hfuse:w:0xd9:m -U efuse:w:0xf4:m</code><br>Puis flasher le firmware 8u2 provenant d'une Arduino UNO : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:8u2_firmware.hex</code><br><br />
Pour la programmation du Bootloader du 328p on utilise directement la fonction "burn bootloader" de l'IDE Arduino. <br />
<br />
Malheureusement notre carte n'est pas reconnue par l'ordinateur avec la commande <code>lsusb</code>. Avec <code>dmesg</code> nous voyons qu'un périphérique USB est détecté mais avec des erreurs, nous essayons de ressouder notre connecteur USB-C à l'air chaud et vérifions au multimètre que les pins sont bien soudés mais nous avons toujours les mêmes erreurs. Après vérification de notre schéma une erreur s'est glissée lors du commit 181625dc05 fait par monsieur Redon, les pins D+ et D- sont inversés. Nous modifions notre carte pour corriger cette inversion. Succès !! notre carte est maintenant bien visible en USB. [[File:Pico2024_B8_lsusb.png|thumb|right|500px|Reconnue (comme une Arduino UNO)]]<br />
<br />
<br />
Après soudure des connecteurs HE10, des leds et de leurs résistances correspondantes, nous avons téleversé notre code pour l'ordonnanceur. Les leds clignotent bien et l'écran 7 segments connecté à la PicoMother fonctionne parfaitement et simultanément.[[File:Pico2024_B8_mother_soudee.png|thumb|left|500px|Carte soudée]]<br />
[[File:Pico2024_B8_mother_ordonnanceur.mp4|thumb|right|500px|Ordonnanceur sur notre carte]]<br />
<br />
Nous testons également que la carte SD est détectable par notre carte mère et c'est bien le cas.<br />
<br style="clear: both;" /><br />
<br />
=Système de fichier=<br />
<br />
[[File:Pico2024_secteur0.jpg|thumb|right|500px|Le contenu du secteur 0]]<br />
Nous passons maintenant à la dernière partie du projet, le système de fichiers. Pour cela nous commençons par essayer de lire et d'écrire un secteur de la carte SD (en mode SPI une carte SD et accessible par blocs (secteurs) de 512 octets), nous utilisons la bibliothèque suivante pour faciliter la gestion de la carte SD :[https://github.com/ryanj1234/SD_TUTORIAL_PART4 Bibliothèque SD]. En modifiant cette bibliothèque on arrive à lire et écrire un secteur de la carte SD. Sur cette photo on lit le secteur 0 de la carte SD, 0x55AA à la fin du secteur signifie que la carte est actuellement formatée avec un système de fichier MBR.<br />
<br />
Après avoir confirmé que nous pouvons lire le bloc 0 nous avons essayé de lire les blocs suivants, or nous obtenions une erreur <code>Address out of range</code>. Le problème vient du fait qu'on utilise une carte SD standard (pas SDHC) et qu'il faut multiplier le numéro de bloc par 512. En effet les cartes SDHC et SDXC sont block-addressed, le bloc 0 est à l'adresse 0, le bloc 1 à l'adresse 1 mais les cartes SD (comme la notre) sont bytes-addressed, le bloc 0 est à l'adresse 0, le bloc 1 à l'adresse 512... Nous avons donc créé une fonction intermédiaire qui multiplie le numero de bloc voulu par 512 (décalage de 9 bits) pour obtenir l'adresse du bloc. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void lecture_block(uint32_t block){<br />
uint8_t res, token;<br />
uint32_t addr = block << 9; //Multiplication par 512<br />
// Lecture du bloc (secteur)<br />
res = SD_readSingleBlock(addr, buffer, &token); //res reçoit un octet décrivant l'état de la carte SD (pas utilisé dans notre code)<br />
// Impression en cas d'erreur<br />
if(!(token & 0xF0)){<br />
UART_pputs("Erreur :\r\n");<br />
SD_printDataErrToken(token);<br />
}<br />
}<br />
</syntaxhighlight><br />
<br style="clear: both;" /><br />
<br />
Une fois les fonctions de lecture et d'écriture de blocs sur la carte SD adaptées à notre carte mère et carte SD nous avons commencé à créer notre pico système de fichiers.<br />
<br style="clear: both;" /><br />
[[File:Pico2024_B8_schema_sysfich.png|thumb|center|800px|Schéma de notre système de fichiers]]<br />
<br style="clear: both;" /> <br />
Nous avons utilisé deux blocs de la carte comme superblocs (table of content) qui contiennent des "descripteurs" de fichiers et pointent vers le premier bloc au sont stockées les données (4 blocs consécutifs). Nous avons choisi de que nos fichiers doivent avoir un nom de 14 caractères maximum, ainsi notre structure Fichier à une taille de 16 octets et on peut en mettre 32 par superbloc (32*16 = 512), deux superblocs suffiront donc pour accéder à 64 fichiers. En tout notre système de fichiers utilise 132096 octets sur la carte SD (4*64*512 + 2*512).<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
struct Fichier{<br />
uint8_t available;<br />
uint8_t starting_block;<br />
char name[FILE_NAME];<br />
}typedef Fichier; //Taille 16 octets<br />
</syntaxhighlight><br />
<br />
Nous avons donc commencé par implémenter la fonction format qui efface tout les blocs de données et rempli les superblocs de structures Fichier disponibles, avec le starting_block adéquat et un nom vide.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void FORMAT(){<br />
UART_pputs("Formatage...\r\n");<br />
//On rempli le buffer de 0x00<br />
clear_buffer();<br />
for(int i = 0; i < TOC_BLOCKS + (BLOCK_PAR_FILE * MAX_FILE); i++){<br />
ecriture_block(i); //on remplit tous les blocs de données et la TOC avec les 0x00<br />
}<br />
Fichier fichier; //Création d'une struct Fichier<br />
fichier.available = 0x01; //Le fichier est disponible <br />
memset(fichier.name, 0x00, FILE_NAME); //nom vide (charactere 00 en hex)<br />
//On écrit la TOC dans le buffer (on place des structs Fichier avec available -> 0x01)<br />
for (int toc = 0; toc < TOC_BLOCKS; toc++) {<br />
for (int j = 0; j < MAX_FILE; j++) {<br />
fichier.starting_block = TOC_BLOCKS + (j * BLOCK_PAR_FILE) + (toc * FILE_PAR_TOC);<br />
int start_index = j * sizeof(Fichier);<br />
memcpy(&buffer[start_index], &fichier, sizeof(Fichier)); // Copie de la structure<br />
}<br />
ecriture_block(toc); // Écriture du buffer dans le superbloc correspondant<br />
}<br />
UART_pputs("Formatage terminé\r\n");<br />
}<br />
</syntaxhighlight><br />
<br />
Pour la commande LS() on parcours les deux superblocs et on envoie sur le port série le noms des fichiers présents sur la carte SD.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void LS(){<br />
UART_pputs("Fichier(s) sur la carte SD :\r\n");<br />
for (int toc = 0; toc < TOC_BLOCKS; toc++){ // On boucle sur les differents blocs de TOC<br />
lecture_block(toc);<br />
for (int i = 0; i < FILE_PAR_TOC; i++){<br />
// Création d'un struct fichier<br />
Fichier fichier;<br />
// On rempli Fichier avec les infos du buffer<br />
memcpy(&fichier, &buffer[i * sizeof(Fichier)], sizeof(Fichier));<br />
// Fichier non dispo donc un fichier est stocké sur la carte<br />
if (fichier.available == 0x00) {<br />
UART_puts(fichier.name); //Affichage du nom du fichier trouvé<br />
UART_pputs("\r\n");<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Nous avons ensuite implémenté les fonctions suivantes:<br />
* APPEND() : crée un fichier sur la carte SD, si il existe déjà les données passées en paramètre sont ajoutées à la fin du fichier existant<br />
* READ() : renvoie sur le port série le contenu du fichier demandé<br />
* REMOVE() : supprime le fichier demandé, on "vide" son descripteur dans le superbloc puis on rempli les 4 blocs de données de 0x00<br />
* RENAME() : permet de renommer un fichier, on remplace simplement sont nom dans son descripteur (pas de modification des blocs de données)<br />
* COPY() : copie d'un fichier source vers un nouveau fichier destination<br />
<br />
Toutes ces fonctions et les fonctions intermédiaires sont dans le fichier <code>SysFich/sys_fichier.c</code> dans notre dépot GIT.<br />
<br />
Pour finir nous avons créé une interface en série pour envoyer les commandes à la carte mère et recevoir le contenu des fichiers. <br />
[[File:Pico2024_B8_sysfich.mp4|thumb|center|800px|Utilisation de notre système de fichiers]]<br />
<br style="clear: both;" /><br />
<br />
Sur la vidéo on peut bien constater que la carte SD crée bien les fichiers comme on le demande, on arrive à les lire (<code>63 6F 75 63 6F 75 20 63 27 65 73 74 20 6C 6F 75 69 73</code> en hexa donne bien le message <code>coucou c'est louis</code>), à concaténer du texte à la fin d'un fichier, de regarder les différents fichiers, de les copier et également les supprimer à volonté.<br />
<br />
=Conclusion=</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=7220SE4Binome2024-82025-01-21T12:24:17Z<p>Alecomt1 : /* Système de fichier */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===Modification Shield===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de notre shield]]<br />
<br />
<br style="clear: both;" /><br />
===Assemblage et test du Shield===<br />
<br />
Nous avons soudé les composants sur le shield puis testé les leds et un afficheur 7 segments connecté (en ISP) sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===Test de la carte SD===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry Pi par exemple et d'obtenir jusqu'à 15w ce qui est largement suffisant pour notre carte mère et les cartes filles des autres binômes.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|469x469px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|588x588px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|412x412px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
[[File:Pico2024_B8_erreur.png|thumb|left|364x364px|D- et D+ inversés]]Nous installons maintenant le firmware dans le 8u2 et le bootloader dans le 328p afin de pouvoir programmer le 328p en utilisant la connexion USB du 8u2. <br>Pour cela il faut d'abord effacer le 8u2 avec les commandes suivantes : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t</code>, Il faut ensuite envoyer la commande <code>erase</code> et <code>quit</code> <br><br />
On peux maintenant modifier les fuses pour notre crystal externe à 16MHz : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xde:m -U hfuse:w:0xd9:m -U efuse:w:0xf4:m</code><br>Puis flasher le firmware 8u2 provenant d'une Arduino UNO : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:8u2_firmware.hex</code><br><br />
Pour la programmation du Bootloader du 328p on utilise directement la fonction "burn bootloader" de l'IDE Arduino. <br />
<br />
Malheureusement notre carte n'est pas reconnue par l'ordinateur avec la commande <code>lsusb</code>. Avec <code>dmesg</code> nous voyons qu'un périphérique USB est détecté mais avec des erreurs, nous essayons de ressouder notre connecteur USB-C à l'air chaud et vérifions au multimètre que les pins sont bien soudés mais nous avons toujours les mêmes erreurs. Après vérification de notre schéma une erreur s'est glissée lors du commit 181625dc05 fait par monsieur Redon, les pins D+ et D- sont inversés. Nous modifions notre carte pour corriger cette inversion. Succès !! notre carte est maintenant bien visible en USB. [[File:Pico2024_B8_lsusb.png|thumb|right|500px|Reconnue (comme une Arduino UNO)]]<br />
<br />
<br />
Après soudure des connecteurs HE10, des leds et de leurs résistances correspondantes, nous avons téleversé notre code pour l'ordonnanceur. Les leds clignotent bien et l'écran 7 segments connecté à la PicoMother fonctionne parfaitement et simultanément.[[File:Pico2024_B8_mother_soudee.png|thumb|left|500px|Carte soudée]]<br />
[[File:Pico2024_B8_mother_ordonnanceur.mp4|thumb|right|500px|Ordonnanceur sur notre carte]]<br />
<br />
Nous testons également que la carte SD est détectable par notre carte mère et c'est bien le cas.<br />
<br style="clear: both;" /><br />
<br />
=Système de fichier=<br />
<br />
[[File:Pico2024_secteur0.jpg|thumb|right|500px|Le contenu du secteur 0]]<br />
Nous passons maintenant à la dernière partie du projet, le système de fichiers. Pour cela nous commençons par essayer de lire et d'écrire un secteur de la carte SD (en mode SPI une carte SD et accessible par blocs (secteurs) de 512 octets), nous utilisons la bibliothèque suivante pour faciliter la gestion de la carte SD :[https://github.com/ryanj1234/SD_TUTORIAL_PART4 Bibliothèque SD]. En modifiant cette bibliothèque on arrive à lire et écrire un secteur de la carte SD. Sur cette photo on lit le secteur 0 de la carte SD, 0x55AA à la fin du secteur signifie que la carte est actuellement formatée avec un système de fichier MBR.<br />
<br />
Après avoir confirmé que nous pouvons lire le bloc 0 nous avons essayé de lire les blocs suivants, or nous obtenions une erreur <code>Address out of range</code>. Le problème vient du fait qu'on utilise une carte SD standard (pas SDHC) et qu'il faut multiplier le numéro de bloc par 512. En effet les cartes SDHC et SDXC sont block-addressed, le bloc 0 est à l'adresse 0, le bloc 1 à l'adresse 1 mais les cartes SD (comme la notre) sont bytes-addressed, le bloc 0 est à l'adresse 0, le bloc 1 à l'adresse 512... Nous avons donc créé une fonction intermédiaire qui multiplie le numero de bloc voulu par 512 (décalage de 9 bits) pour obtenir l'adresse du bloc. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void lecture_block(uint32_t block){<br />
uint8_t res, token;<br />
uint32_t addr = block << 9; //Multiplication par 512<br />
// Lecture du bloc (secteur)<br />
res = SD_readSingleBlock(addr, buffer, &token); //res reçoit un octet décrivant l'état de la carte SD (pas utilisé dans notre code)<br />
// Impression en cas d'erreur<br />
if(!(token & 0xF0)){<br />
UART_pputs("Erreur :\r\n");<br />
SD_printDataErrToken(token);<br />
}<br />
}<br />
</syntaxhighlight><br />
<br style="clear: both;" /><br />
<br />
Une fois les fonctions de lecture et d'écriture de blocs sur la carte SD adaptées à notre carte mère et carte SD nous avons commencé à créer notre pico système de fichiers.<br />
<br style="clear: both;" /><br />
[[File:Pico2024_B8_schema_sysfich.png|thumb|center|800px|Schéma de notre système de fichiers]]<br />
<br style="clear: both;" /> <br />
Nous avons utilisé deux blocs de la carte comme superblocs (table of content) qui contiennent des "descripteurs" de fichiers et pointent vers le premier bloc au sont stockées les données (4 blocs consécutifs). Nous avons choisi de que nos fichiers doivent avoir un nom de 14 caractères maximum, ainsi notre structure Fichier à une taille de 16 octets et on peut en mettre 32 par superbloc (32*16 = 512), deux superblocs suffiront donc pour accéder à 64 fichiers.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
struct Fichier{<br />
uint8_t available;<br />
uint8_t starting_block;<br />
char name[FILE_NAME];<br />
}typedef Fichier; //Taille 16 octets<br />
</syntaxhighlight><br />
<br />
Nous avons donc commencé par implementer la fonction format qui efface tout les blocs de données et rempli les superblocs de structures Fichier disponibles, avec le starting_block adéquat et un nom vide.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void FORMAT(){<br />
UART_pputs("Formatage...\r\n");<br />
//On rempli le buffer de 0x00<br />
clear_buffer();<br />
for(int i = 0; i < TOC_BLOCKS + (BLOCK_PAR_FILE * MAX_FILE); i++){<br />
ecriture_block(i); //on remplit tous les blocs de données et la TOC avec les 0x00<br />
}<br />
Fichier fichier; //Création d'une struct Fichier<br />
fichier.available = 0x01; //Le fichier est disponible <br />
memset(fichier.name, 0x00, FILE_NAME); //nom vide (charactere 00 en hex)<br />
//On écrit la TOC dans le buffer (on place des structs Fichier avec available -> 0x01)<br />
for (int toc = 0; toc < TOC_BLOCKS; toc++) {<br />
for (int j = 0; j < MAX_FILE; j++) {<br />
fichier.starting_block = TOC_BLOCKS + (j * BLOCK_PAR_FILE) + (toc * FILE_PAR_TOC);<br />
int start_index = j * sizeof(Fichier);<br />
memcpy(&buffer[start_index], &fichier, sizeof(Fichier)); // Copie de la structure<br />
}<br />
ecriture_block(toc); // Écriture du buffer dans le superbloc correspondant<br />
}<br />
UART_pputs("Formatage terminé\r\n");<br />
}<br />
</syntaxhighlight><br />
<br />
Pour la commande LS() on parcours les deux superblocs et on envoie sur le port série le noms des fichiers présents sur la carte SD.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void LS(){<br />
UART_pputs("Fichier(s) sur la carte SD :\r\n");<br />
for (int toc = 0; toc < TOC_BLOCKS; toc++){ // On boucle sur les differents blocs de TOC<br />
lecture_block(toc);<br />
for (int i = 0; i < FILE_PAR_TOC; i++){<br />
// Création d'un struct fichier<br />
Fichier fichier;<br />
// On rempli Fichier avec les infos du buffer<br />
memcpy(&fichier, &buffer[i * sizeof(Fichier)], sizeof(Fichier));<br />
// Fichier non dispo donc un fichier est stocké sur la carte<br />
if (fichier.available == 0x00) {<br />
UART_puts(fichier.name); //Affichage du nom du fichier trouvé<br />
UART_pputs("\r\n");<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Nous avons ensuite implémenté les fonctions suivantes:<br />
* APPEND() : crée un fichier sur la carte SD, si il existe déjà les données passées en paramètre sont ajoutées à la fin du fichier existant<br />
* READ() : renvoie sur le port série le contenu du fichier demandé<br />
* REMOVE() : supprime le fichier demandé, on "vide" son descripteur dans le superbloc puis on rempli les 4 blocs de données de 0x00<br />
* RENAME() : permet de renommer un fichier, on remplace simplement sont nom dans son descripteur (pas de modification des blocs de données)<br />
* COPY() : copie d'un fichier source vers un nouveau fichier destination<br />
<br />
Toutes ces fonctions et les fonctions intermédiaires sont dans le fichier <code>SysFich/sys_fichier.c</code> dans notre dépot GIT.<br />
<br />
Pour finir nous avons créé une interface en série pour envoyer les commandes à la carte mère et recevoir le contenu des fichiers. <br />
[[File:Pico2024_B8_sysfich.mp4|thumb|center|800px|Utilisation de notre système de fichiers]]<br />
<br style="clear: both;" /><br />
<br />
Sur la vidéo on peut bien constater que la carte SD crée bien les fichiers comme on le demande, on arrive à les lire (<code>63 6F 75 63 6F 75 20 63 27 65 73 74 20 6C 6F 75 69 73</code> en hexa donne bien le message <code>coucou c'est louis </code>, à concaténer du texte à la fin d'un fichier, de regarder les différents fichiers et également les supprimer à volonté.<br />
<br />
=Conclusion=</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=7219SE4Binome2024-82025-01-21T12:19:43Z<p>Alecomt1 : /* Système de fichier */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===Modification Shield===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de notre shield]]<br />
<br />
<br style="clear: both;" /><br />
===Assemblage et test du Shield===<br />
<br />
Nous avons soudé les composants sur le shield puis testé les leds et un afficheur 7 segments connecté (en ISP) sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===Test de la carte SD===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry Pi par exemple et d'obtenir jusqu'à 15w ce qui est largement suffisant pour notre carte mère et les cartes filles des autres binômes.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|469x469px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|588x588px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|412x412px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
[[File:Pico2024_B8_erreur.png|thumb|left|364x364px|D- et D+ inversés]]Nous installons maintenant le firmware dans le 8u2 et le bootloader dans le 328p afin de pouvoir programmer le 328p en utilisant la connexion USB du 8u2. <br>Pour cela il faut d'abord effacer le 8u2 avec les commandes suivantes : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t</code>, Il faut ensuite envoyer la commande <code>erase</code> et <code>quit</code> <br><br />
On peux maintenant modifier les fuses pour notre crystal externe à 16MHz : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xde:m -U hfuse:w:0xd9:m -U efuse:w:0xf4:m</code><br>Puis flasher le firmware 8u2 provenant d'une Arduino UNO : <code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:8u2_firmware.hex</code><br><br />
Pour la programmation du Bootloader du 328p on utilise directement la fonction "burn bootloader" de l'IDE Arduino. <br />
<br />
Malheureusement notre carte n'est pas reconnue par l'ordinateur avec la commande <code>lsusb</code>. Avec <code>dmesg</code> nous voyons qu'un périphérique USB est détecté mais avec des erreurs, nous essayons de ressouder notre connecteur USB-C à l'air chaud et vérifions au multimètre que les pins sont bien soudés mais nous avons toujours les mêmes erreurs. Après vérification de notre schéma une erreur s'est glissée lors du commit 181625dc05 fait par monsieur Redon, les pins D+ et D- sont inversés. Nous modifions notre carte pour corriger cette inversion. Succès !! notre carte est maintenant bien visible en USB. [[File:Pico2024_B8_lsusb.png|thumb|right|500px|Reconnue (comme une Arduino UNO)]]<br />
<br />
<br />
Après soudure des connecteurs HE10, des leds et de leurs résistances correspondantes, nous avons téleversé notre code pour l'ordonnanceur. Les leds clignotent bien et l'écran 7 segments connecté à la PicoMother fonctionne parfaitement et simultanément.[[File:Pico2024_B8_mother_soudee.png|thumb|left|500px|Carte soudée]]<br />
[[File:Pico2024_B8_mother_ordonnanceur.mp4|thumb|right|500px|Ordonnanceur sur notre carte]]<br />
<br />
Nous testons également que la carte SD est détectable par notre carte mère et c'est bien le cas.<br />
<br style="clear: both;" /><br />
<br />
=Système de fichier=<br />
<br />
[[File:Pico2024_secteur0.jpg|thumb|right|500px|Le contenu du secteur 0]]<br />
Nous passons maintenant à la dernière partie du projet, le système de fichiers. Pour cela nous commençons par essayer de lire et d'écrire un secteur de la carte SD (en mode SPI une carte SD et accessible par blocs (secteurs) de 512 octets), nous utilisons la bibliothèque suivante pour faciliter la gestion de la carte SD :[https://github.com/ryanj1234/SD_TUTORIAL_PART4 Bibliothèque SD]. En modifiant cette bibliothèque on arrive à lire et écrire un secteur de la carte SD. Sur cette photo on lit le secteur 0 de la carte SD, 0x55AA à la fin du secteur signifie que la carte est actuellement formatée avec un système de fichier MBR.<br />
<br />
Après avoir confirmé que nous pouvons lire le bloc 0 nous avons essayé de lire les blocs suivants, or nous obtenions une erreur <code>Address out of range</code>. Le problème vient du fait qu'on utilise une carte SD standard (pas SDHC) et qu'il faut multiplier le numéro de bloc par 512. En effet les cartes SDHC et SDXC sont block-addressed, le bloc 0 est à l'adresse 0, le bloc 1 à l'adresse 1 mais les cartes SD (comme la notre) sont bytes-addressed, le bloc 0 est à l'adresse 0, le bloc 1 à l'adresse 512... Nous avons donc créé une fonction intermédiaire qui multiplie le numero de bloc voulu par 512 (décalage de 9 bits) pour obtenir l'adresse du bloc. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void lecture_block(uint32_t block){<br />
uint8_t res, token;<br />
uint32_t addr = block << 9; //Multiplication par 512<br />
// Lecture du bloc (secteur)<br />
res = SD_readSingleBlock(addr, buffer, &token); //res reçoit un octet décrivant l'état de la carte SD (pas utilisé dans notre code)<br />
// Impression en cas d'erreur<br />
if(!(token & 0xF0)){<br />
UART_pputs("Erreur :\r\n");<br />
SD_printDataErrToken(token);<br />
}<br />
}<br />
</syntaxhighlight><br />
<br style="clear: both;" /><br />
<br />
Une fois les fonctions de lecture et d'écriture de blocs sur la carte SD adaptées à notre carte mère et carte SD nous avons commencé à créer notre pico système de fichiers.<br />
<br style="clear: both;" /><br />
[[File:Pico2024_B8_schema_sysfich.png|thumb|center|800px|Schéma de notre système de fichiers]]<br />
<br style="clear: both;" /> <br />
Nous avons utilisé deux blocs de la carte comme superblocs (table of content) qui contiennent des "descripteurs" de fichiers et pointent vers le premier bloc au sont stockées les données (4 blocs consécutifs). Nous avons choisi de que nos fichiers doivent avoir un nom de 14 caractères maximum, ainsi notre structure Fichier à une taille de 16 octets et on peut en mettre 32 par superbloc (32*16 = 512), deux superblocs suffiront donc pour accéder à 64 fichiers.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
struct Fichier{<br />
uint8_t available;<br />
uint8_t starting_block;<br />
char name[FILE_NAME];<br />
}typedef Fichier; //Taille 16 octets<br />
</syntaxhighlight><br />
<br />
Nous avons donc commencé par implementer la fonction format qui efface tout les blocs de données et rempli les superblocs de structures Fichier disponibles, avec le starting_block adéquat et un nom vide.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void FORMAT(){<br />
UART_pputs("Formatage...\r\n");<br />
//On rempli le buffer de 0x00<br />
clear_buffer();<br />
for(int i = 0; i < TOC_BLOCKS + (BLOCK_PAR_FILE * MAX_FILE); i++){<br />
ecriture_block(i); //on remplit tous les blocs de données et la TOC avec les 0x00<br />
}<br />
Fichier fichier; //Création d'une struct Fichier<br />
fichier.available = 0x01; //Le fichier est disponible <br />
memset(fichier.name, 0x00, FILE_NAME); //nom vide (charactere 00 en hex)<br />
//On écrit la TOC dans le buffer (on place des structs Fichier avec available -> 0x01)<br />
for (int toc = 0; toc < TOC_BLOCKS; toc++) {<br />
for (int j = 0; j < MAX_FILE; j++) {<br />
fichier.starting_block = TOC_BLOCKS + (j * BLOCK_PAR_FILE) + (toc * FILE_PAR_TOC);<br />
int start_index = j * sizeof(Fichier);<br />
memcpy(&buffer[start_index], &fichier, sizeof(Fichier)); // Copie de la structure<br />
}<br />
ecriture_block(toc); // Écriture du buffer dans le superbloc correspondant<br />
}<br />
UART_pputs("Formatage terminé\r\n");<br />
}<br />
</syntaxhighlight><br />
<br />
Pour la commande LS() on parcours les deux superblocs et on envoie sur le port série le noms des fichiers présents sur la carte SD.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void LS(){<br />
UART_pputs("Fichier(s) sur la carte SD :\r\n");<br />
for (int toc = 0; toc < TOC_BLOCKS; toc++){ // On boucle sur les differents blocs de TOC<br />
lecture_block(toc);<br />
for (int i = 0; i < FILE_PAR_TOC; i++){<br />
// Création d'un struct fichier<br />
Fichier fichier;<br />
// On rempli Fichier avec les infos du buffer<br />
memcpy(&fichier, &buffer[i * sizeof(Fichier)], sizeof(Fichier));<br />
// Fichier non dispo donc un fichier est stocké sur la carte<br />
if (fichier.available == 0x00) {<br />
UART_puts(fichier.name); //Affichage du nom du fichier trouvé<br />
UART_pputs("\r\n");<br />
}<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Nous avons ensuite implémenté les fonctions suivantes:<br />
* APPEND() : crée un fichier sur la carte SD, si il existe déjà les données passées en paramètre sont ajoutées à la fin du fichier existant<br />
* READ() : renvoie sur le port série le contenu du fichier demandé<br />
* REMOVE() : supprime le fichier demandé, on "vide" son descripteur dans le superbloc puis on rempli les 4 blocs de données de 0x00<br />
* RENAME() : permet de renommer un fichier, on remplace simplement sont nom dans son descripteur (pas de modification des blocs de données)<br />
* COPY() : copie d'un fichier source vers un nouveau fichier destination<br />
<br />
Toutes ces fonctions et les fonctions intermédiaires sont dans le fichier <code>SysFich/sys_fichier.c</code> dans notre dépot GIT.<br />
<br />
Pour finir nous avons créé une interface en série pour envoyer les commandes à la carte mère et recevoir le contenu des fichiers. <br />
[[File:Pico2024_B8_sysfich.mp4|thumb|center|800px|Utilisation de notre système de fichiers]]<br />
<br style="clear: both;" /><br />
<br />
=Conclusion=</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6932SE4Binome2024-82024-12-04T11:07:47Z<p>Alecomt1 : /* Carte mère */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|500px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
Nous installons maintenant le firmware dans le 8u2 et le bootloader dans le 328p afin de pouvoir programmer le 328p en utilisant la connexion USB du 8u2.<br />
Pour cela il faut effacer le 8u2, modifier les fuses pour notre crystal externe à 16MHz, puis flashez le firmware 8u2 provenant d'une Arduino UNO.<br />
<code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t</code>Il faut ensuite envoyer la commande <code>erase</code> et <code>quit</code> <br><code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xde:m -U hfuse:w:0xd9:m -U efuse:w:0xf4:m</code> commande pour la modification des fuses<br><code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:8u2_firmware.hex</code><br />
<br />
[[File:Pico2024_B8_erreur.jpeg|thumb|left|400px|D- et D+ inversés]]<br />
Malheureusement notre carte n'est pas reconnue par l'ordinateur avec la commande <code>lsusb</code>. Avec <code>dmesg</code> on voit bien un périphérique USB mais avec des erreurs, nous avons essayé de ressouder notre connecteur USB-C et vérifions au multimètre que les pins sont bien soudés mais nous avons toujours les mêmes erreurs. Après vérification de notre schéma une erreur s'est glissée lors du commit 181625dc05 fait par monsieur Redon, les pins D+ et D- sont inversés. Nous modifions notre carte pour corriger cette erreur, notre carte est bien reconnue par l'ordinateur.<br />
Après soudure des connecteurs HE10 et des leds et résistances correspondantes, nous avons téleverser notre code pour l'ordonnanceur, l'écran sept segments écrivant bien et les leds clignotent donc notre carte est fonctionnelle.<br />
<br />
[[File:Pico2024_B8_mother_soudee.jpeg|thumb|left|500px|Carte soudée]]<br />
[[File:Pico2024_B8_lsusb.png|thumb|right|500px|Reconnue (comme une Arduino UNO)]]<br />
<br style="clear: both;" /><br />
[[File:Pico2024_B8_mother_ordonnanceur.mp4|thumb|left|500px|Ordonnanceur sur notre carte]]</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6931SE4Binome2024-82024-12-04T11:05:53Z<p>Alecomt1 : /* Carte mère */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|500px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
Nous installons maintenant le firmware dans le 8u2 et le bootloader dans le 328p afin de pouvoir programmer le 328p en utilisant la connexion USB du 8u2.<br />
Pour cela il faut effacer le 8u2, modifier les fuses pour notre crystal externe à 16MHz, puis flashez le firmware 8u2 provenant d'une Arduino UNO.<br />
<code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t</code>Il faut ensuite envoyer la commande <code>erase</code> et <code>quit</code> <br><code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xde:m -U hfuse:w:0xd9:m -U efuse:w:0xf4:m</code> commande pour la modification des fuses<br><code>avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:8u2_firmware.hex</code><br />
<br />
[[File:Pico2024_B8_erreur.jpeg|thumb|left|400px|D- et D+ inversés]]<br />
Malheureusement notre carte n'est pas reconnue par l'ordinateur avec la commande <code>lsusb</code>. Avec <code>dmesg</code> on voit bien un périphérique USB mais avec des erreurs, nous avons essayé de ressouder notre connecteur USB-C et vérifions au multimètre que les pins sont bien soudés mais nous avons toujours les mêmes erreurs. Après vérification de notre schéma une erreur s'est glissée lors du commit 181625dc05 fait par monsieur Redon, les pins D+ et D- sont inversés. Nous modifions notre carte pour corriger cette erreur, notre carte est bien reconnue par l'ordinateur.<br />
Après soudure des connecteurs HE10 et des leds et résistances correspondantes, nous avons téleverser notre code pour l'ordonnanceur, l'écran sept segments écrivant bien et les leds clignotent donc notre carte est fonctionnelle.<br />
<br />
[[File:Pico2024_B8_mother_soudee.jpeg|thumb|left|500px|Carte soudée]]<br />
[[File:Pico2024_B8_lsusb.jpeg|thumb|right|500px|Reconnue (comme une Arduino UNO)]]<br />
<br style="clear: both;" /><br />
[[File:Pico2024_B8_mother_ordonnanceur|thumb|left|500px|Ordonnanceur sur notre carte]]</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Pico2024_B8_lsusb.png&diff=6928Fichier:Pico2024 B8 lsusb.png2024-12-04T09:43:50Z<p>Alecomt1 : </p>
<hr />
<div></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6914SE4Binome2024-82024-12-02T10:35:09Z<p>Alecomt1 : /* Carte mère */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|700px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
<code><br />
avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t<br />
</code><br />
cela nous emmène dans un termial dans lequel nous pouvous débloquer la modification des fuses grâce à la commande<br />
<code><br />
avrdude> erase<br />
</code><br />
avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xde:m -U hfuse:w:0xd9:m -U efuse:w:0xf4:m<br />
avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:at90usb82-bl-usb-1_0_5.hex<br />
</code><br />
problème de dtr, pas de resest possible sur le 8u2 car pas de boutons, ne démarre pas sur le bootloader donc pas possible de le voir grâce à <code>lsusb</code></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6913SE4Binome2024-82024-12-02T10:33:13Z<p>Alecomt1 : /* Carte mère */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|700px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
<code><br />
avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t<br />
avrdude> erase<br />
<br />
avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U lfuse:w:0xde:m -U hfuse:w:0xd9:m -U efuse:w:0xf4:m<br />
avrdude -c stk500v1 -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:at90usb82-bl-usb-1_0_5.hex<br />
</code><br />
problème de dtr, pas de resest possible sur le 8u2 car pas de boutons, ne démarre pas sur le bootloader donc pas possible de le voir grâce à <code>lsusb</code></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6912SE4Binome2024-82024-12-02T10:14:29Z<p>Alecomt1 : /* Carte mère */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|700px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
<code><br />
avrdude -c avrisp -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t<br />
avrdude> erase<br />
<br />
avrdude -c avrisp -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:at90usb82-bl-usb-1_0_5.hex<br />
</code><br />
problème de dtr, pas de resest possible sur le 8u2 car pas de boutons, ne démarre pas sur le bootloader donc pas possible de le voir grâce à <code>lsusb</code></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6911SE4Binome2024-82024-12-02T10:13:59Z<p>Alecomt1 : /* Carte mère */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|700px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
<code><br />
avrdude -c avrisp -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t<br />
avrdude> erase<br />
<br />
avrdude -c avrisp -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:at90usb82-bl-usb-1_0_5.hex<br />
<code><br />
problème de dtr, pas de resest possible sur le 8u2 car pas de boutons, ne démarre pas sur le bootloader donc pas possible de le voir grâce à <syntaxhighlight lang="c" line="1" start="1">lsusb</syntaxhighlight><code>lsusb</code></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6910SE4Binome2024-82024-12-02T10:12:26Z<p>Alecomt1 : </p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|700px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /><br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
avrdude -c avrisp -p atmega8u2 -P /dev/ttyACM0 -b 19200 -t<br />
avrdude> erase<br />
<br />
avrdude -c avrisp -p atmega8u2 -P /dev/ttyACM0 -b 19200 -U flash:w:at90usb82-bl-usb-1_0_5.hex<br />
</syntaxhighlight><br />
problème de dtr, pas de resest possible sur le 8u2 car pas de boutons, ne démarre pas sur le bootloader donc pas possible de le voir grâce à <syntaxhighlight lang="c" line="1" start="1">lsusb</syntaxhighlight></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6857SE4Binome2024-82024-11-20T10:55:47Z<p>Alecomt1 : /* Carte mère */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|700px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6856SE4Binome2024-82024-11-20T10:55:23Z<p>Alecomt1 : /* Carte mère */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|75%|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|40%|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6855SE4Binome2024-82024-11-20T10:55:02Z<p>Alecomt1 : /* Carte mère */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|40%|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6854SE4Binome2024-82024-11-20T10:53:31Z<p>Alecomt1 : /* Carte mère */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
===Tâche série===<br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
===Tâche 7 segments===<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
===Etat endormi===<br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction <code>_delays_ms()</code> à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche endormie est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle. Ainsi chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
Notre nouvel ordonnanceur qui appelle <code>Sleeping()</code> <br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
} while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
Cette fonction endors la tâche pendant la durée t (en millisecondes).<br />
On remet ensuite le timer à 0 et on lance l'interruption manuellement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
Voici notre struture modifiée pour ajouter l'état endormi<br />
On utilise une union pour representer le temps d'endormissement.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int situation; //1 pour endormi, 0 pour éveillé <br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]<br />
<br />
Nous avons reçu notre PCB, pour commencer nous assemblons les composants minimums pour faire clignoter une LED avec le 328p.<br />
[[File:Pico2024_B8_PCB_recu.jpeg|thumb|left|500px|Le naked PCB]]<br />
[[File:Pico2024_B8_PC1.jpeg|thumb|right|500px|Ca fonctionne]]<br />
<br style="clear: both;" /><br />
En programmant par le port ISP avec une Arduino as ISP on arrive à faire clignoter la LED reliée sur PC1 du 328p. On soude ensuite le minimum pour tester l'AtMega8u2, on arrive à faire clignoter deux led reliées a ses broches. <br />
<br />
[[File:Pico2024_B8_8U2.jpeg|thumb|left|500px|Les atmega sont soudés]]<br />
[[File:Pico2024_B8_double_blinking.mp4|thumb|right|500px|Blinking lights]]<br />
<br style="clear: both;" /></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6628SE4Binome2024-82024-11-13T10:31:50Z<p>Alecomt1 : /* Ordonnanceur */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
Une fois que les tâches ont été correctement séparées, il a fallu ajuster notre ordonnanceur pour garantir que les délais de chaque tâche soient respectés. En effet, avec notre méthode actuelle qui repose sur l'utilisation de la fonction _delays_ms() à chaque ajout de tâche, le temps total d'exécution augmente de manière cumulative. Par exemple, avec deux tâches, un délai de 200 ms prendrait 400 ms, et avec trois tâches, cela atteindrait 600 ms. Pour résoudre ce problème, nous avons décidé d'ajouter un état à chaque tâche, permettant de les "endormir" lorsqu'elles ne sont pas appelées, et de les "réveiller" lorsqu'elles le sont. Grâce à ce système, chaque fois qu'une tâche est exécutée, on décrémente son timer de 20 millisecondes à chaque cycle, et ce processus continue jusqu'à son prochain appel. Ainsi, nous garantissons que chaque tâche respecte son délai sans interférer avec l'exécution des autres tâches.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
}while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int sit;<br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6624SE4Binome2024-82024-11-13T10:29:07Z<p>Alecomt1 : /* Ordonnanceur */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine.<br />
<br />
Lors de ce projet nous allons réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur une carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|left|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Pour notre ordonnanceur il est important d'initialiser les taches, notamment leur pointeur de pile. <br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void init_task(int t){<br />
uint16_t oldSP = SP;<br />
SP = Taches[t].stack;<br />
uint16_t adresse = (uint16_t)Taches[t].start;<br />
asm volatile("push %0" : : "r" (adresse & 0x00ff));<br />
asm volatile("push %0" : : "r" ((adresse & 0xff00) >> 8));<br />
portSAVE_Registers();<br />
Taches[t].stack = SP;<br />
SP = oldSP;<br />
}<br />
</syntaxhighlight><br />
<br />
A chaque interruption de l'ISR (toutes les 20ms) on sauvegarde le contexte de la tache en cours, l'ordonnanceur passe à la tache suivante et on restaure le contexte de cette tache.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
ISR(TIMER1_COMPA_vect, ISR_NAKED){<br />
/* Sauvegarde du contexte de la tâche interrompue */<br />
portSAVE_Registers();<br />
Taches[courant].stack = SP;<br />
/* Appel à l'ordonnanceur */<br />
ordonnanceur();<br />
/* Récupération du contexte de la tâche ré-activée */<br />
SP = Taches[courant].stack;<br />
portRESTORE_Registers();<br />
asm volatile("reti");<br />
}<br />
</syntaxhighlight><br />
<br />
Une fois l’ordonnanceur capable de lancer deux tâches en parallèle, nous nous sommes attaqués à la communication série de la carte par USB. Pour ce faire, nous utilisons l’application minicom coté PC qui permet une connexion série. Il faut initialiser les paramètres de la connexion, notre carte renvoie le message reçu dans le terminal.<br />
<br />
<br style="clear: both;" /><br />
Ci joint les deux taches responsables de l'envoi et de la reception de données par le protocole série, <code>serial_buffer</code> est une variable globale utilisée pour stocker les messages reçus et à envoyer. Les fonctions <code>Serial_Transmit()</code> et <code>Serial_Receive()</code> sont déclarées dans <code>pico_serial.h</code> et proviennent de la documentation AVR.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SerialWrite(){<br />
while (1){<br />
Serial_Transmit('\r\n');<br />
Serial_Transmit(serial_buffer);<br />
}<br />
}<br />
<br />
void SerialRead(){<br />
while(1){<br />
serial_buffer = Serial_Receive();<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
[[File:SerialSetup.png|thumb|right|400px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|left|400px|Message reçu par le port série]]<br />
<br style="clear: both;" /><br />
Lors de ce test notre atmega envoi "LOULOUTOINE" en boucle sur le port série.<br />
<br />
<br />
Nous ajoutons maintenant une tâche permettant de communiquer avec l'écran 7 segments par la communication SPI (toujours en parallèle des autres tâches).<br />
Voici par exemple deux des fonctions SPI, il faut préalablement initialiser la communication SPI avec les registres SPI.<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void SPI_send(uint8_t data) {<br />
DISPLAY_PORT &= ~(1<<DISPLAY_PIN); //On met le pin CS de l'écran à l'état bas pour l'activer<br />
SPDR = data;<br />
while (!(SPSR & (1 << SPIF)));<br />
DISPLAY_PORT |= (1<<DISPLAY_PIN); // On relache l'écran <br />
}<br />
<br />
void clearDisplaySPI() {<br />
SPI_send(0x76); // Commande pour effacer l'écran et remettre le curseur a gauche<br />
}<br />
</syntaxhighlight><br />
Pour afficher un caractère sur l'écran il suffit donc d'appeler <code>SPI_send()</code> en passant en paramètre le caractère à envoyer.<br />
[[File:Pico2024_B8_ordos7s_video.mp4|thumb|center|600px|Les 5 tâches en parallèle]]<br />
<br style="clear: both;" /><br />
<br />
Une fois les tâches séparées correctement, il fallait modifier notre ordonanceur pour que les délais de chaque tâches soit respectés. En effet avec notre méthode actuel qui utilise le "_delays_ms()" à chaque ajout de tâches, celles ci prennent de plus en plus de temps. Par exemple avec deux tâches, un delay de 200ms prendrais 400ms et avec 3 tâches 600ms. Pour palier ce problème, il nous faut rajouter un état à chaque tâches pour pouvoir les endormir quand elles ne sont pas appellés et les reveillés sinon. Avec ce système, chqua fois qu'une tâche est appellée on décompte 20 millisecondes de son timer et on fait ceci jusqu'à son prochain appel. Ceci assure que les tâches durent bien la durée pour laquelle on les appel.<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void Sleeping(){<br />
for (int i = 0; i < NB_TASKS;i++){<br />
if (Taches[i].etat.sit == ENDORMI) Taches[i].etat.time.tempsendormi -= 20;<br />
if (Taches[i].etat.time.tempsendormi <= 0) {<br />
Taches[i].etat.time.tempsendormi = 0;<br />
Taches[i].etat.sit = ACTIF;<br />
}<br />
}<br />
}<br />
</syntaxhighlight><br />
<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void ordonnanceur(){<br />
PORTC ^= 0x01; // On fait clignoter une des led (J1) à chaque fois que l'ordonnanceur est appelé<br />
Sleeping();<br />
do{<br />
courant ++;<br />
if (courant == NB_TASKS) courant = 0;<br />
}while (Taches[courant].etat.sit == ENDORMI);<br />
}<br />
</syntaxhighlight><br />
<br />
<br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
void makeSleep(int t){<br />
Taches[courant].etat.sit = ENDORMI;<br />
Taches[courant].etat.time.tempsendormi = t;<br />
TCNT1 = 0;<br />
TIMER1_COMPA_vect();<br />
}<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="c" line="1" start="1"><br />
#define ENDORMI 1<br />
#define ACTIF 0<br />
<br />
typedef union{<br />
int tempsendormi;<br />
} Time;<br />
<br />
typedef struct{<br />
int sit;<br />
Time time;<br />
} Etat;<br />
<br />
typedef struct task{<br />
void (*start)(void);<br />
uint16_t stack;<br />
Etat etat;<br />
} task;<br />
</syntaxhighlight><br />
<br />
=Carte mère=<br />
<br />
Parmi notre groupe, nous sommes le binôme en charge de la carte mère. <br />
Nous avons décidé d'utiliser un Atmega 328p qui sera programmé avec <code>avr-dude</code> pour cela notre carte mère comportera également un Atmega8u2 qui servira de programmateur et d'interface serie/USB. <br />
<br />
Notre carte étant similaire à une Arduino UNO avec le shield intégré nous mesurerons lors de la prochaine séance la consommation de celle ci afin d'estimer la conso de la future carte mère. Avec cette mesure et les estimations de consommation des différentes cartes filles nous réaliserons un bilan de puissance détaillé.<br />
<br />
Pour l'instant nous avons prévu une alimentation par un port USB C, ayant connecté les pins CC1 et CC2 à des resistances de 5.1k nous obtenons 5v et 3A max. Il sera donc simple d'alimenter notre carte avec un câble USB, chargeur de téléphone ou alimentation de Raspberry par exemple et d'obtenir jusqu'à 15w ce qui semble largement suffisant.<br />
<br />
Notre PCB est terminé, voici le schéma et un rendu du PCB final. <br />
[[File:Pico2024_B8_sch_PCB.pdf|thumb|left|500px|Le schéma final (en 3 pages)]]<br />
[[File:Pico2024_B8_rendu_PCB.png|thumb|right|500px|Le PCB final]]<br />
<br style="clear: both;" /><br />
Les fichiers GERBER sont disponibles dans notre dépot [https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT]</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6240SE4Binome2024-82024-10-14T10:15:39Z<p>Alecomt1 : /* Ordonnanceur */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine<br />
Ce projet est le principal de notre semestre, il s'agit de réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur la carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|right|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Une fois l'ordonnanceur capable de lancer deux tâches en parallèles, nous nous sommes attaqués à la communication série de la cart par USB. Pour se faire nous utilisons l'application minicom qui utilise le terminal pour émuler une connexion Série. Il faut initialiser les paramètres de la connexion et le terminal renvoie directement ce que notre carte envoie comme message.<br />
<br />
[[File:Minicom.png|thumb|left|300px|Interface de départ du Minicom]]<br />
[[File:SerialSetup.png|thumb|center|300px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|right|300px|Message reçu par le port série]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Il faut maintenant que nous faisions la partie reçeption de la carte.<br />
<br />
=Carte mère=<br />
<br />
Parmis notre groupe, nous somme le binome en charge de la carte mère.</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6239SE4Binome2024-82024-10-14T10:14:11Z<p>Alecomt1 : /* Ordonnanceur */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine<br />
Ce projet est le principal de notre semestre, il s'agit de réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur la carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|right|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Une fois l'ordonnanceur capable de lancer deux tâches en parallèles, nous nous sommes attaqués à la communication série de la cart par USB. Pour se faire nous utilisons l'application minicom qui utilise le terminal pour émuler une connexion Série. Il faut initialiser les paramètres de la connexion et le terminal renvoie directement ce que la connexion reçoit.<br />
<br />
[[File:Minicom.png|thumb|left|300px|Interface de départ du Minicom]]<br />
[[File:SerialSetup.png|thumb|center|300px|Paramètres du Minicom]]<br />
[[File:TestWriteSerial.png|thumb|right|300px|Message reçu par le port série]]<br />
<br />
<br style="clear: both;" /><br />
<br />
=Carte mère=<br />
<br />
Parmis notre groupe, nous somme le binome en charge de la carte mère.</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6238SE4Binome2024-82024-10-14T10:13:07Z<p>Alecomt1 : /* Ordonnanceur */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine<br />
Ce projet est le principal de notre semestre, il s'agit de réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur la carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|right|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Une fois l'ordonnanceur capable de lancer deux tâches en parallèles, nous nous sommes attaqués à la communication série de la cart par USB. Pour se faire nous utilisons l'application minicom qui utilise le terminal pour émuler une connexion Série. Il faut initialiser les paramètres de la connexion et le terminal renvoie directement ce que la connexion reçoit.<br />
<br />
[[File:Minicom.png|thumb|left|300px|Les LEDs clignotent]]<br />
[[File:SerialSetup.png|thumb|center|300px|Les LEDs clignotent]]<br />
[[File:TestWriteSerial.png|thumb|right|300px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
=Carte mère=<br />
<br />
Parmis notre groupe, nous somme le binome en charge de la carte mère.</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:TestWriteSerial.png&diff=6237Fichier:TestWriteSerial.png2024-10-14T10:12:44Z<p>Alecomt1 : </p>
<hr />
<div></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:SerialSetup.png&diff=6236Fichier:SerialSetup.png2024-10-14T10:12:35Z<p>Alecomt1 : </p>
<hr />
<div></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Minicom.png&diff=6235Fichier:Minicom.png2024-10-14T10:12:21Z<p>Alecomt1 : </p>
<hr />
<div></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6234SE4Binome2024-82024-10-14T10:12:09Z<p>Alecomt1 : /* Ordonnanceur */</p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine<br />
Ce projet est le principal de notre semestre, il s'agit de réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur la carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
===23 septembre 2024===<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
===30 septembre 2024===<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
===1 octobre 2024===<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h'. La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
[[File:Pico2024_B8_SD.png|thumb|right|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Ordonnanceur=<br />
<br />
Nous avons commencé par réaliser un ordonnanceur simple pour effectuer deux taches simples (clignotement de deux LEDs).<br />
Comme visible sur la vidéo, la LED bleue et la LED orange clignotent bien à des fréquences différentes, la LED rouge clignote à chaque appel de l'ordonnanceur.<br />
[[File:Pico2024_B8_ordo_video.mp4|thumb|center|600px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
Une fois l'ordonnanceur capable de lancer deux tâches en parallèles, nous nous sommes attaqués à la communication série de la cart par USB. Pour se faire nous utilisons l'application minicom qui utilise le terminal pour émuler une connexion Série. Il faut initialiser les paramètres de la connexion et le terminal renvoie directement ce que la connexion reçoit.<br />
<br />
[[File:Minicom.png|thumb|left|400px|Les LEDs clignotent]]<br />
[[File:SerialSetup.png|thumb|center|400px|Les LEDs clignotent]]<br />
[[File:TestWriteSerial.png|thumb|right|400px|Les LEDs clignotent]]<br />
<br />
<br style="clear: both;" /><br />
<br />
=Carte mère=<br />
<br />
Parmis notre groupe, nous somme le binome en charge de la carte mère.</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6074SE4Binome2024-82024-10-01T13:31:21Z<p>Alecomt1 : </p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine<br />
Ce projet est le principal de notre semestre, il s'agit de réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur la carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
==23 septembre 2024==<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
==30 septembre 2024==<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
==1 octobre 2024==<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h' <br />
La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
<br />
<br />
[[File:Pico2024_B8_SD.png|thumb|right|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Carte mère=<br />
==1 octobre 2024==<br />
Parmis notre groupe, nous somme le binome en charge de la carte mère.</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6067SE4Binome2024-82024-10-01T12:35:11Z<p>Alecomt1 : </p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine<br />
Ce projet est le principal de notre semestre, il s'agit de réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur la carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
==23 septembre 2024==<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
==30 septembre 2024==<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br style="clear: both;" /><br />
==1 octobre 2024==<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h' <br />
La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
<br />
<br />
[[File:Pico2024_B8_SD.png|thumb|right|400px|Lecture de la carte SD]]<br />
<br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Carte mère=</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Pico2024_B8_SD.png&diff=6066Fichier:Pico2024 B8 SD.png2024-10-01T12:34:34Z<p>Alecomt1 : </p>
<hr />
<div></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6065SE4Binome2024-82024-10-01T12:33:59Z<p>Alecomt1 : </p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine<br />
Ce projet est le principal de notre semestre, il s'agit de réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur la carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PicoShield=<br />
Pour débuter cet ordinateur, nous allons tester les fonctionnalités de base grâce à un shield que nous connectons à une carte arduino.<br />
==23 septembre 2024==<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|400px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|400px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
==30 septembre 2024==<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|400px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|400px|L'afficheur externe]]<br />
<br />
==1 octobre 2024==<br />
Nous avons testé le connecteur de carte SD, à l'aide de la bibliothèque arduino 'SD.h' <br />
La carte est bien reconnue, nous pouvons voir la taille mémoire de la carte et les fichiers présents dessus.<br />
<br />
[[File:Pico2024_B8_SD.png|thumb|right|400px|Lecture de la carte SD]]<br />
<br style="clear: both;" /><br />
Nous avons testé toutes les fonctionnalités de base avec le PicoShield, nous pouvons donc passer à la suite.<br />
<br style="clear: both;" /><br />
<br />
=Carte mère=</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-8&diff=6064SE4Binome2024-82024-10-01T12:23:13Z<p>Alecomt1 : </p>
<hr />
<div>Wiki du projet Pico BONNINGRE Louis LECOMTE Antoine<br />
Ce projet est le principal de notre semestre, il s'agit de réaliser un pico-ordinateur qui comporte plusieurs fonctionnalités qui sont implémentées grâce à des cartes filles que l'on vient brancher sur la carte mère.<br />
<br />
<br />
[https://gitea.plil.fr/lbonning/pico-se4_binome8 GIT du projet]<br />
<br />
=PIcoShield=<br />
==23 septembre 2024==<br />
<br />
Modification du PCB du shield, ajout d'une puce mémoire dans le cas ou la connexion à la carte SD ne fonctionne pas.<br />
<br />
[[File:Pico2024_B8_sch_motherboard.pdf|thumb|left|600px|Le schéma de la carte mère]]<br />
[[File:Pico2024_B8_pcb_motherboard.png|thumb|right|600px|Le PCB de la carte mère]]<br />
<br />
<br style="clear: both;" /><br />
=30 septembre 2024=<br />
<br />
Nous avons soudé les composants sur la carte puis testé les led et un afficheur 7 segments connecté sur un des ports pour carte fille <br />
<br />
[[File:Pico2024_B8_led.png|thumb|left|600px|Les LEDs fonctionnent]]<br />
[[File:Pico2024_B8_7seg.png|thumb|right|600px|L'afficheur externe]]<br />
<br />
<br />
<br style="clear: both;" /></div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5624SE3Binome2023-52024-06-11T14:31:15Z<p>Alecomt1 : /* GIT */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:LED allumée sur batterie.jpg|thumb|left|150px|LED allumée en fonctionnement sur batterie]]<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5623SE3Binome2023-52024-06-11T14:31:05Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:LED allumée sur batterie.jpg|thumb|left|150px|LED allumée en fonctionnement sur batterie]]<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5622SE3Binome2023-52024-06-11T14:30:53Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:LED allumée sur batterie.jpg|thumb|left|150px|LED allumée en fonctionnement sur batterie]]<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5621SE3Binome2023-52024-06-11T14:30:40Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:LED allumée sur batterie.jpg|thumb|left|150px|LED allumée en fonctionnement sur batterie]]<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5620SE3Binome2023-52024-06-11T14:30:26Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:LED allumée sur batterie.jpg|thumb|left|200px|LED allumée en fonctionnement sur batterie]]<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5619SE3Binome2023-52024-06-11T14:30:11Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:LED allumée sur batterie.jpg|thumb|left|400px|LED allumée en fonctionnement sur batterie]]<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5618SE3Binome2023-52024-06-11T14:29:27Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
[[Fichier:LED allumée sur batterie.jpg|vignette|LED allumée en fonctionnement sur batterie]]<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:LED_allum%C3%A9e_sur_batterie.jpg&diff=5617Fichier:LED allumée sur batterie.jpg2024-06-11T14:28:57Z<p>Alecomt1 : </p>
<hr />
<div>b</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5616SE3Binome2023-52024-06-11T14:28:24Z<p>Alecomt1 : /* GIT */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5615SE3Binome2023-52024-06-11T14:28:17Z<p>Alecomt1 : /* GIT */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5614SE3Binome2023-52024-06-11T14:28:09Z<p>Alecomt1 : /* GIT */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5613SE3Binome2023-52024-06-11T14:27:58Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|500px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|500px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|500px|Voiture après recharge]]<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5612SE3Binome2023-52024-06-11T14:27:24Z<p>Alecomt1 : /* GIT */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|Voiture après recharge]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5611SE3Binome2023-52024-06-11T14:27:14Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|left|Voiture après recharge]]<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5610SE3Binome2023-52024-06-11T14:22:22Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|200px|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|200px|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|right|200px|Voiture après recharge]]<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5609SE3Binome2023-52024-06-11T14:21:31Z<p>Alecomt1 : /* GIT */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|right|Voiture après recharge]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5608SE3Binome2023-52024-06-11T14:21:21Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|right|Voiture après recharge]]<br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5607SE3Binome2023-52024-06-11T14:20:34Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<br />
[[Fichier:Voiture déchargée.mp4|thumb|left|Voiture déchargée]]<br />
[[Fichier:Voiture en charge.mp4|thumb|center|Voiture en charge]]<br />
[[Fichier:Voiture après recharge.mp4|thumb|right|Voiture après recharge]]<br />
<br />
<gallery><br />
File:Voiture déchargée.mp4|Voiture déchargée<br />
File:Voiture en charge.mp4|Voiture en charge<br />
File:Voiture après recharge.mp4|Voiture après recharge<br />
</gallery><br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1https://projets-se.plil.fr/mediawiki/index.php?title=SE3Binome2023-5&diff=5606SE3Binome2023-52024-06-11T14:19:12Z<p>Alecomt1 : /* Brasage des composants */</p>
<hr />
<div>= Projet Groupe 5 : Voiture Programmable =<br />
Cette page est consacrée à la présentation du projet SE3 réalisé par BOURSAULT Rémi & LECOMTE Antoine, qui est porté sur la création d'une voiture contrôlé par programmation.<br />
<br />
== Présentation : ==<br />
<br />
=== Objectifs ===<br />
Les objectifs du projets sont : <br />
<br />
* Concevoir une voiture fonctionnant sur batterie, avec un ATMega.<br />
* Intégrer des clignotants fonctionnels.<br />
* Permettre à la voiture d'avancer ou reculer, toujours en utilisant l'ATMega.<br />
* Ajout d'un gyrophare.<br />
<br />
=== Ressources ===<br />
Pour atteindre ces différents objectifs, nous aurons besoins des ressources suivantes :<br />
<br />
* Un microcontrôleur ATMega16U4/ATMega32U4<br />
* Des LEDS<br />
* Deux moteurs à courant continu<br />
* Un châssis <br />
* Des dipôles classiques<br />
* Un gyrophare<br />
<br />
<br />
<br />
Après avoir choisi notre projet et nos différents objectifs pour ce projet, nous avons commencé à travailler sur le schéma de montage sur KiCAD afin de pouvoir ensuite faire le PCB et le routage qui sera envoyé à une usine pour imprimer nos cartes. Les fonctions et composants principaux de notre projet sont les suivants.<br />
<br />
== Fonction sur le schéma : ==<br />
<br />
<br />
=== Microcontrôleur ===<br />
La partie indispensable de tous montages électroniques, le cerveau de la voiture. Sans le microcontrôleur rien dans ce projet n'est possible, il permet de gérer les informations. qui sont transmises dans toutes la carte. C'est un microcontrôleur ATMega32u4, ce n'est pas le plus puissant, mais pour la taille du projet que nous faisons c'est bien assez. Il possède assez d'entrées/sorties pour ce que nous voulons en faire.[[Fichier:Microcontroleu.png||thumb|left|300px|Schéma du microcontrôleur]]<br />
[[Fichier:Pin configuration atmega.png||thumb|center|300px|Configuration des pins sur l'atmega]]<br />
<br />
=== Commande Moteur ===<br />
Ce bloc est celui qui actionne les moteurs et leur dit quand s'arrêter. Celui-ci est composé d'un TB6612FNG, un driver pour moteur qui ne sert qu'à ça. Il prend sept signaux en entrée trois pour gérer chaque moteur et un signal de standby. Nous avons utilisé la datasheet pour savoir comment le schématiser et quels composants utilisé pour que celui-ci fonctionne dans des conditions optimales. <br />
<br />
Il est nécessaire d'ajouter ce composant, car les signaux de sortie délivrés par l'ATMega sont trop faibles pour alimenter un moteur. Ce driver vient, à partir d'une tension d'alimentation Vcc amplifier le signal de commande délivré par l'ATMega pour que les moteurs aient l'alimentation adéquate. <br />
<br />
<br />
<br />
<br />
[[Fichier:Datasheet TB6612.png||thumb|left|300px|PCB routé de la carte]]<br />
[[Fichier:Commande Moteur.png||thumb|center|300px|Schéma du bloc de commande des moteurs]]<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
=== Chargeur LI-PO ===<br />
Comme notre voiture fonctionnera sur batterie, il faut un moyen de la recharger, ceci se faisant par l'intermédiaire d'un port USB, il faut un bloc pour adapter le courant que reçoit l'USB pour que cela corresponde aux caractéristiques de notre batterie.<br />
<br />
<br />
[[Fichier:Chargeur lipo.png||thumb|center|300px|Schéma du chargeur]]<br />
<br />
<br />
=== Utilisation de la Batterie ===<br />
Ce bloc permet de séparer l'alimentation en USB et sur batterie. Lorsqu'un cavalier est présent sur J6, VBAT est directement relié à Vcc et ainsi la batterie sert d'alimentation pour la carte. Il est impératif de débrancher l'USB avant de mettre le cavalier, pour éviter tout court-circuit. Lorsqu'on enlève le cavalier, on peut brancher l'USB et la carte fonctionne en filaire.[[Fichier:Utilisation baterie.png||thumb|center|300px|Schéma du switch batterie]]<br />
=== Connecteur USB ===<br />
On dispose de deux connecteurs USB, un pour recharger la batterie, et un autre pour transmettre les données, qui servira à implanter un programme dans notre microcontrôleur.[[Fichier:Connecteur USBs.png||thumb|center|300px|Schéma des connecteur USB]]<br />
=== Connecteur ISP ===<br />
Pour charger le bootloader sur le microcontrôleur si besoin.[[Fichier:Connecteur ISP.png||thumb|center|300px|Schéma du connecteur ISP]]<br />
=== Diodes Électroluminescentes ===<br />
[[Fichier:LED voiture.png||thumb|center|300px|Schéma des LEDS]]<br />
<br />
== PCB et routage : ==<br />
Après avoir fini toutes nos fonctions et le schéma, nous nous sommes attaqué au PCB de la carte, il nous a fallu quelque essais pour obtenir une disposition qui nous convienne et qui facilite le routage.[[Fichier:Vue3D.png||thumb|left|300px|Vue 3D de la carte]]<br />
[[Fichier:PCB voiture.png||thumb|center|300px|PCB routé de la carte]]<br />
<br />
<br />
<br />
== Brasage des composants ==<br />
Une fois les cartes reçues, nous nous sommes attaqués à la brasure des différents composants. Nous avons commencé par le microcontrôleur, le cristal et les résistances et capacités associées. Dès le départ nous avons eu des problèmes avec le brasage, des pattes soudées entre elles, le cristal mal posé. Mais notre plus gros problème a été l'allocation des pins du microcontrôleur. Nous ne le savions pas au moment de la création de notre PCB et nous n'y avons pas fait attention, mais des pins sont spécialement attribuées au MISO, MOSI et SOCKET. Pins que nous devons utilisés pour envoyer le bootloader sur la microcontrôleur via le programmateur ISP (en orange sur le schéma). Nous avons donc dû improviser une solution. Nous avons coupé les pistes et relié par des fils les broches de l'ISP aux pins correspondantes. A cause de cette erreur nos LEDs D2 et D3 ne sont plus utilisables.<br />
<br />
[[Fichier:Atmega pin mosi.png|thumb|center|800x|Pins de l'atmega utilisés pour l'ISP]]<br />
<br />
<br />
<br />
Une fois ce problème réglé, nous avons pu passer à la suite, la gestion des moteurs. Pour ce faire il n'y a pas eu autant de problèmes que sur la partie microcontrôleur, nous avons simplement soudé le contrôleur de moteurs, un TB6612FNG, puis les broches sur lesquelles nous allons venir brancher les moteurs, et enfin les fils directement sur les broches des moteurs. Nous avons également utilisé du plastique thermo rétractable pour que les fils soient protégés et restent soudés aux moteurs durant toute la durée du projet. Les moteurs étant prêt à l'emploi, nous les avons testé pour savoir si tout était fonctionnelle. Une fois confirmé, nous avons pris des bouchons de bouteilles comme roues et mis des élastiques autour pour avoir de la traction lors de nos différents essais.<br />
<br />
[[Fichier:Moteur et roues.jpg|thumb|center|300px|Moteurs et roues]]<br />
<br />
Pour tester toute notre carte, nous avons crée un code sous le nom de helloworld.c qui rempli différente fonction, allumer ou faire clignoter les LEDs en fonction du déplacement de la voiture et, bien évidemment, déplacer la voiture. La voiture réagissant comme nous le souhaitons, nous décidons donc de passer à l'étape suivante, le fonctionnement sur batterie. Ce n'est pas la partie la plus compliquée, il suffit de brasé les broches permettant d'accueillir la batterie puis celles destinées au cavalier. Une fois le tout installé sur notre carte, nous la testons et tout fonctionne normalement. <br />
<br />
[[Fichier:Voiture appui bouton.mp4|thumb|center|Voiture fonctionnant sur batterie]]<br />
<br />
<br />
<br />
<br />
Comme il nous reste encore un peu de temps, nous décidons de nous attaqués à la dernière partie, la recharge de la batterie. Comme pour la partie de fonctionnement sur batterie, il n'y a aucune partie de code, il suffit de soudé des composants en plus sur la carte pour que la nouvelle fonctionnalité soit active. Donc nous nous y sommes mis et encore une fois il n'y a aucun problème.<br />
<br />
<gallery><br />
File:Voiture déchargée.mp4|Voiture déchargée<br />
File:Voiture en charge.mp4|Voiture en charge<br />
File:Voiture après recharge.mp4|Voiture après recharge<br />
</gallery><br />
<br />
== GIT ==<br />
Vous trouverez dans le lien [https://archives.plil.fr/rboursau/premier-systeme-embarque.git GIT] de notre projet, tous les fichiers de création de la carte se trouvent dans le dossier projet_voiture, le code envoyé pour tester la voiture dans le dossier cod.<br />
<br />
<br />
<br />
<br />
dfu-programmer atmega16u4 erase<br />
<br />
dfu-programmer atmega16u4 flash helloworld.hex<br />
<br />
dfu-programmer atmega16u4 reset<br />
<br />
puis débranché et rebranché la voiture<br />
<br />
appuyé sur le bouton HWB puis RESET, relaché RESET puis HWB pour que la voiture repasse en mode DFU bootloader<br />
<br />
appuyé sur le bouton reset pour arreter le cycle de la voiture au milieu</div>Alecomt1