<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="fr">
	<id>https://projets-se.plil.fr/mediawiki/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Itepeli</id>
	<title>projets-se.plil.fr - Contributions [fr]</title>
	<link rel="self" type="application/atom+xml" href="https://projets-se.plil.fr/mediawiki/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Itepeli"/>
	<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php/Sp%C3%A9cial:Contributions/Itepeli"/>
	<updated>2026-11-18T19:51:31Z</updated>
	<subtitle>Contributions</subtitle>
	<generator>MediaWiki 1.39.1</generator>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7277</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7277"/>
		<updated>2025-01-25T17:53:03Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré|1094x1094px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une adresse IP 10.0.0.1 qui est l&#039;IP client défini dans l&#039;exemple LUFA.&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa2.png|centré|vignette|854x854px|ip a où l&#039;on voit la carte (interface usb0)]]&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping comme le montre la vidéo.&lt;br /&gt;
[[Fichier:Ping2.mp4|centré|vignette|Ping de la carte (et la LED qui clignote lorsqu&#039;elle reçoit le ping)]]&lt;br /&gt;
Le ping fonctionne par usb donc on peut communiquer avec l&#039;extérieur, maintenant il faut le faire aussi par port SPI pour communiquer avec la carte mère.&lt;br /&gt;
[[Fichier:Pong.mp4|centré|vignette|Vidéo test de communication par SPI]]&lt;br /&gt;
[[Fichier:Pongscreen.png|centré|vignette|Pong]]&lt;br /&gt;
Pour cela, on a pris le code pong.c fourni par Mr Redon qui permet de tester la communication par SPI. Le premier essai s&#039;avère être un échec. Le problème venait d&#039;une erreur de conception du shield. On a eu le même problème que le binôme 7 donc on a fait la même manipulation et la communication par SPI fonctionne ! On arrive donc à communiquer avec l&#039;Arduino.&lt;br /&gt;
&lt;br /&gt;
=== Protocole: ===&lt;br /&gt;
Pour envoyer et recevoir des paquets Ethernet avec le PC et la carte, on doit développer notre propre protocole. On a développé un premier protocole test appelé GPOAT (Greatest Protocol Of All Time) qui est composé de la manière suivante:&lt;br /&gt;
[[Fichier:Gpoat.png|centré|vignette|504x504px|Structure d&#039;un paquet GPOAT]]&lt;br /&gt;
Le but de ce paquet est de recevoir 2 nombres de 16 octets et y effectuer une opération qui dépend du bit de point faible de Operation.&lt;br /&gt;
&lt;br /&gt;
Pour reconnaitre ce protocole, on a fait un nouvel Ether Type &amp;quot;GPOAT&amp;quot; référencé à 0x2706.&lt;br /&gt;
&lt;br /&gt;
Ce protocole est intéressant car il permet de montrer que le PC peut envoyer un paquet à la carte, la carte réalise une action qui est l&#039;opération demandé puis renvoie un paquet qui contient la réponse.&lt;br /&gt;
&lt;br /&gt;
Voici comment est traité le paquet et comment la réponse est forgée:&lt;br /&gt;
[[Fichier:Traitement.png|centré|vignette|752x752px|Traitement des données GPOAT]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Dans l&#039;exemple ci dessous, la carte reçoit 2 valeurs qui sont &amp;quot;ff ff&amp;quot; et il lui est demandé de les diviser entre eux, ce à quoi la carte répond avec comme valeur &amp;quot;1&amp;quot;.&lt;br /&gt;
[[Fichier:Gpoat test.png|centré|vignette|401x401px|Test d&#039;envoi et réception d&#039;un GPOAT (le premier est le paquet envoyé par le PC et le 2ème est la réponse de la carte)]]&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Traitement.png&amp;diff=7276</id>
		<title>Fichier:Traitement.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Traitement.png&amp;diff=7276"/>
		<updated>2025-01-25T17:51:58Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Traitement&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7273</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7273"/>
		<updated>2025-01-25T16:52:47Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré|1094x1094px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une adresse IP 10.0.0.1 qui est l&#039;IP client défini dans l&#039;exemple LUFA.&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa2.png|centré|vignette|854x854px|ip a où l&#039;on voit la carte (interface usb0)]]&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping comme le montre la vidéo.&lt;br /&gt;
[[Fichier:Ping2.mp4|centré|vignette|Ping de la carte (et la LED qui clignote lorsqu&#039;elle reçoit le ping)]]&lt;br /&gt;
Le ping fonctionne par usb donc on peut communiquer avec l&#039;extérieur, maintenant il faut le faire aussi par port SPI pour communiquer avec la carte mère.&lt;br /&gt;
[[Fichier:Pong.mp4|centré|vignette|Vidéo test de communication par SPI]]&lt;br /&gt;
[[Fichier:Pongscreen.png|centré|vignette|Pong]]&lt;br /&gt;
Pour cela, on a pris le code pong.c fourni par Mr Redon qui permet de tester la communication par SPI. Le premier essai s&#039;avère être un échec. Le problème venait d&#039;une erreur de conception du shield. On a eu le même problème que le binôme 7 donc on a fait la même manipulation et la communication par SPI fonctionne ! On arrive donc à communiquer avec l&#039;Arduino.&lt;br /&gt;
&lt;br /&gt;
=== Protocole: ===&lt;br /&gt;
Pour envoyer et recevoir des paquets Ethernet avec le PC et la carte, on doit développer notre propre protocole. On a développé un premier protocole test appelé GPOAT (Greatest Protocol Of All Time) qui est composé de la manière suivante:&lt;br /&gt;
[[Fichier:Gpoat.png|centré|vignette|504x504px|Structure d&#039;un paquet GPOAT]]&lt;br /&gt;
Le but de ce paquet est de recevoir 2 nombres de 16 octets et y effectuer une opération qui dépend du bit de point faible de Operation.&lt;br /&gt;
&lt;br /&gt;
Ce protocole est intéressant car il permet de montrer que le PC peut envoyer un paquet à la carte, la carte réalise une action qui est l&#039;opération demandé puis renvoie un paquet qui contient la réponse. Dans l&#039;exemple ci dessous, la carte reçoit 2 valeurs qui sont &amp;quot;ff ff&amp;quot; et il lui est demandé de les diviser entre eux, ce à quoi la carte répond avec comme valeur &amp;quot;1&amp;quot;.&lt;br /&gt;
[[Fichier:Gpoat test.png|centré|vignette|401x401px|Test d&#039;envoi et réception d&#039;un GPOAT (le premier est le paquet envoyé par le PC et le 2ème est la réponse de la carte)]]&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7272</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7272"/>
		<updated>2025-01-25T16:52:12Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré|1094x1094px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une adresse IP 10.0.0.1 qui est l&#039;IP client défini dans l&#039;exemple LUFA.&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa2.png|centré|vignette|854x854px|ip a où l&#039;on voit la carte (interface usb0)]]&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping comme le montre la vidéo.&lt;br /&gt;
[[Fichier:Ping2.mp4|centré|vignette|Ping de la carte (et la LED qui clignote lorsqu&#039;elle reçoit le ping)]]&lt;br /&gt;
Le ping fonctionne par usb donc on peut communiquer avec l&#039;extérieur, maintenant il faut le faire aussi par port SPI pour communiquer avec la carte mère.&lt;br /&gt;
[[Fichier:Pong.mp4|centré|vignette|Vidéo test de communication par SPI]]&lt;br /&gt;
[[Fichier:Pongscreen.png|centré|vignette|Pong]]&lt;br /&gt;
Pour cela, on a pris le code pong.c fourni par Mr Redon qui permet de tester la communication par SPI. Le premier essai s&#039;avère être un échec. Le problème venait d&#039;une erreur de conception du shield. On a eu le même problème que le binôme 7 donc on a fait la même manipulation et la communication par SPI fonctionne ! On arrive donc à communiquer avec l&#039;Arduino.&lt;br /&gt;
&lt;br /&gt;
=== Protocole: ===&lt;br /&gt;
Pour envoyer et recevoir des paquets Ethernet avec le PC et la carte, on doit développer notre propre protocole. On a développé un premier protocole test appelé GPOAT (Greatest Protocol Of All Time) qui est composé de la manière suivante:&lt;br /&gt;
[[Fichier:Gpoat.png|centré|vignette|504x504px|Structure d&#039;un paquet GPOAT]]&lt;br /&gt;
Le but de ce paquet est de recevoir 2 nombres de 16 octets et y effectuer une opération qui dépend du bit de point faible de Operation.&lt;br /&gt;
&lt;br /&gt;
Ce protocole est intéressant car il permet de montrer que le PC peut envoyer un paquet à la carte, la carte réalise une action qui est l&#039;opération demandé puis renvoie un paquet qui contient la réponse. Dans l&#039;exemple ci dessous, la carte reçoit 2 valeurs qui sont &amp;quot;ff ff&amp;quot; et il lui est demandé de les diviser entre eux, ce à quoi la carte répond avec comme valeur &amp;quot;1&amp;quot;.&lt;br /&gt;
[[Fichier:Gpoat test.png|centré|vignette|401x401px|Test d&#039;envoi et réception d&#039;un GOAT (le premier est le paquet envoyé par le PC et le 2ème est la réponse de la carte)]]&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Gpoat_test.png&amp;diff=7270</id>
		<title>Fichier:Gpoat test.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Gpoat_test.png&amp;diff=7270"/>
		<updated>2025-01-25T16:49:46Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Test&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7261</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7261"/>
		<updated>2025-01-25T16:12:28Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré|1094x1094px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une adresse IP 10.0.0.1 qui est l&#039;IP client défini dans l&#039;exemple LUFA.&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa2.png|centré|vignette|854x854px|ip a où l&#039;on voit la carte (interface usb0)]]&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping comme le montre la vidéo.&lt;br /&gt;
[[Fichier:Ping2.mp4|centré|vignette|Ping de la carte (et la LED qui clignote lorsqu&#039;elle reçoit le ping)]]&lt;br /&gt;
Le ping fonctionne par usb donc on peut communiquer avec l&#039;extérieur, maintenant il faut le faire aussi par port SPI pour communiquer avec la carte mère.&lt;br /&gt;
[[Fichier:Pong.mp4|centré|vignette|Vidéo test de communication par SPI]]&lt;br /&gt;
[[Fichier:Pongscreen.png|centré|vignette|Pong]]&lt;br /&gt;
Pour cela, on a pris le code pong.c fourni par Mr Redon qui permet de tester la communication par SPI. Le premier essai s&#039;avère être un échec. Le problème venait d&#039;une erreur de conception du shield. On a eu le même problème que le binôme 7 donc on a fait la même manipulation et la communication par SPI fonctionne ! On arrive donc à communiquer avec l&#039;Arduino.&lt;br /&gt;
&lt;br /&gt;
=== Protocole: ===&lt;br /&gt;
Pour envoyer et recevoir des paquets Ethernet avec le PC et la carte, on doit développer notre propre protocole. On a développé un premier protocole test appelé GPOAT (Greatest Protocol Of All Time) qui est composé de la manière suivante:&lt;br /&gt;
[[Fichier:Gpoat.png|centré|vignette|504x504px|Structure d&#039;un paquet GPOAT]]&lt;br /&gt;
Le but de ce paquet est de recevoir 2 nombres de 16 octets et y effectuer une opération qui dépend du bit de point faible de Operation.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Gpoat.png&amp;diff=7259</id>
		<title>Fichier:Gpoat.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Gpoat.png&amp;diff=7259"/>
		<updated>2025-01-25T16:02:55Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Structure d&#039;un paquet GPOAT&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7100</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7100"/>
		<updated>2025-01-10T11:37:53Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré|1094x1094px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une adresse IP 10.0.0.1 qui est l&#039;IP client défini dans l&#039;exemple LUFA.&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa2.png|centré|vignette|854x854px|ip a où l&#039;on voit la carte (interface usb0)]]&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping comme le montre la vidéo.&lt;br /&gt;
[[Fichier:Ping2.mp4|centré|vignette|Ping de la carte (et la LED qui clignote lorsqu&#039;elle reçoit le ping)]]&lt;br /&gt;
Le ping fonctionne par usb donc on peut communiquer avec l&#039;extérieur, maintenant il faut le faire aussi par port SPI pour communiquer avec la carte mère.&lt;br /&gt;
[[Fichier:Pong.mp4|centré|vignette|Vidéo test de communication par SPI]]&lt;br /&gt;
[[Fichier:Pongscreen.png|centré|vignette|Pong]]&lt;br /&gt;
Pour cela, on a pris le code pong.c fourni par Mr Redon qui permet de tester la communication par SPI. Le premier essai s&#039;avère être un échec. Le problème venait d&#039;une erreur de conception du shield. On a eu le même problème que le binôme 7 donc on a fait la même manipulation et la communication par SPI fonctionne ! On arrive donc à communiquer avec l&#039;arduino.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7099</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7099"/>
		<updated>2025-01-10T11:37:23Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré|1094x1094px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une adresse IP 10.0.0.1 qui est l&#039;IP client défini dans l&#039;exemple LUFA.&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa2.png|centré|vignette|854x854px|ip a où l&#039;on voit la carte (interface usb0)]]&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping comme le montre la vidéo.&lt;br /&gt;
[[Fichier:Ping2.mp4|centré|vignette|Ping de la carte (et la LED qui clignote lorsqu&#039;elle reçoit le ping)]]&lt;br /&gt;
[[Fichier:Pongscreen.png|centré|vignette|Pong]]&lt;br /&gt;
Le ping fonctionne par usb donc on peut communiquer avec l&#039;extérieur, maintenant il faut le faire aussi par port SPI pour communiquer avec la carte mère.&lt;br /&gt;
[[Fichier:Pong.mp4|centré|vignette|Vidéo test de communication par SPI]]&lt;br /&gt;
Pour cela, on a pris le code pong.c fourni par Mr Redon qui permet de tester la communication par SPI. Le premier essai s&#039;avère être un échec. Le problème venait d&#039;une erreur de conception du shield. On a eu le même problème que le binôme 7 donc on a fait la même manipulation et la communication par SPI fonctionne ! On arrive donc à communiquer avec l&#039;arduino.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Pongscreen.png&amp;diff=7098</id>
		<title>Fichier:Pongscreen.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Pongscreen.png&amp;diff=7098"/>
		<updated>2025-01-10T11:36:50Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;screen du pong&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7097</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7097"/>
		<updated>2025-01-10T11:35:52Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré|1094x1094px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une adresse IP 10.0.0.1 qui est l&#039;IP client défini dans l&#039;exemple LUFA.&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa2.png|centré|vignette|854x854px|ip a où l&#039;on voit la carte (interface usb0)]]&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping comme le montre la vidéo.&lt;br /&gt;
[[Fichier:Ping2.mp4|centré|vignette|Ping de la carte (et la LED qui clignote lorsqu&#039;elle reçoit le ping)]]&lt;br /&gt;
&lt;br /&gt;
Le ping fonctionne par usb donc on peut communiquer avec l&#039;extérieur, maintenant il faut le faire aussi par port SPI pour communiquer avec la carte mère.&lt;br /&gt;
[[Fichier:Pong.mp4|centré|vignette|Vidéo test de communication par SPI]]&lt;br /&gt;
Pour cela, on a pris le code pong.c fourni par Mr Redon qui permet de tester la communication par SPI. Le premier essai s&#039;avère être un échec. Le problème venait d&#039;une erreur de conception du shield. On a eu le même problème que le binôme 7 donc on a fait la même manipulation et la communication par SPI fonctionne ! On arrive donc à communiquer avec l&#039;arduino.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7096</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7096"/>
		<updated>2025-01-10T11:33:22Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré|1094x1094px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une adresse IP 10.0.0.1 qui est l&#039;IP client défini dans l&#039;exemple LUFA.&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa2.png|centré|vignette|854x854px|ip a où l&#039;on voit la carte (interface usb0)]]&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping comme le montre la vidéo.&lt;br /&gt;
[[Fichier:Ping2.mp4|vignette|Ping de la carte (et la LED qui clignote lorsqu&#039;elle reçoit le ping)]]&lt;br /&gt;
&lt;br /&gt;
Le ping fonctionne par usb donc on peut communiquer avec l&#039;extérieur, maintenant il faut le faire aussi par port SPI pour communiquer avec la carte mère.&lt;br /&gt;
[[Fichier:Pong.mp4|vignette|Vidéo test de communication par SPI]]&lt;br /&gt;
Pour cela, on a pris le code pong.c fourni par Mr Redon qui permet de tester la communication par SPI. Le premier essai s&#039;avère être un échec. Le problème venait d&#039;une erreur de conception du shield. On a eu le même problème que le binôme 7 donc on a fait la même manipulation et la communication par SPI fonctionne !&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Pong.mp4&amp;diff=7095</id>
		<title>Fichier:Pong.mp4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Pong.mp4&amp;diff=7095"/>
		<updated>2025-01-10T11:32:15Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;video pong&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7094</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7094"/>
		<updated>2025-01-10T11:13:48Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré|1094x1094px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une addresse IP 10.0.0.1, c&#039;est l&#039;IP Client défini dans l&#039;exemple LUFA et qui est utilisé dans le code certain protocole.&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa2.png|centré|vignette|854x854px|ip a où l&#039;on voit la carte (interface usb0)]]&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping.&lt;br /&gt;
[[Fichier:Ping2.mp4|vignette|Ping de la carte (et la LED qui clignote lorsqu&#039;elle reçoit le ping)]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
On ping 10.0.0.2 qui est son IP Serveur défini dans l&#039;exemple LUFA.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ping2.mp4&amp;diff=7093</id>
		<title>Fichier:Ping2.mp4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ping2.mp4&amp;diff=7093"/>
		<updated>2025-01-10T11:13:09Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;ping de la carte&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ipa2.png&amp;diff=7092</id>
		<title>Fichier:Ipa2.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ipa2.png&amp;diff=7092"/>
		<updated>2025-01-10T11:11:37Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;ip a avec la carte réseau&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7079</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7079"/>
		<updated>2025-01-06T14:48:45Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : /* Programmation de la carte */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré|1094x1094px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une addresse IP 21.21.21.21 (on avait pas trop d&#039;inspiration donc on a pris le numero de notre machine).&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa.jpg|vignette|ip a où l&#039;on voit la carte (interface usb0)|centré|854x854px]]&lt;br /&gt;
&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping.[[Fichier:Ping.jpg|vignette|Ping de la carte.|centré|570x570px]]&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7077</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7077"/>
		<updated>2025-01-06T14:47:05Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : /* Programmation de la carte */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une addresse IP 21.21.21.21 (on avait pas trop d&#039;inspiration donc on a pris le numero de notre machine).&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
[[Fichier:Ipa.jpg|vignette|ip a où l&#039;on voit la carte (interface usb0)|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping.[[Fichier:Ping.jpg|vignette|Ping de la carte.|centré]]&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7075</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7075"/>
		<updated>2025-01-06T14:43:57Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, notre carte est détectée comme on peut le voir avec un lsusb.&lt;br /&gt;
[[Fichier:LSUSB RNDIS.jpg|vignette|Lsusb qui détecte la carte.]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Ensuite, on lui a attribué une addresse IP 21.21.21.21 (on avait pas trop d&#039;inspiration donc on a pris le numero de notre machine).&lt;br /&gt;
[[Fichier:Ipa.jpg|vignette|ip a où l&#039;on voit la carte (interface usb0)]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Enfin, avec un ip a, on remarque qu&#039;elle a son interface usb0 et qu&#039;elle est DOWN. Avec un ip link set usb0 up, la carte est prête à communiquer.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
En effet elle est belle est bien prête à communiquer car on arrive à la ping.&lt;br /&gt;
[[Fichier:Ping.jpg|vignette|Ping de la carte.]]&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ping.jpg&amp;diff=7073</id>
		<title>Fichier:Ping.jpg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ping.jpg&amp;diff=7073"/>
		<updated>2025-01-06T14:43:12Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;ping de la carte&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ipa.jpg&amp;diff=7069</id>
		<title>Fichier:Ipa.jpg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ipa.jpg&amp;diff=7069"/>
		<updated>2025-01-06T14:41:05Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;ip a du RNDIS&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:LSUSB_RNDIS.jpg&amp;diff=7067</id>
		<title>Fichier:LSUSB RNDIS.jpg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:LSUSB_RNDIS.jpg&amp;diff=7067"/>
		<updated>2025-01-06T14:38:02Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;lsusb&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7061</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7061"/>
		<updated>2025-01-06T14:23:15Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;br /&gt;
&lt;br /&gt;
=== Programmation de la carte ===&lt;br /&gt;
Cette section est dédiée à la programmation de la carte. Tout d&#039;abord, en utilisant les codes RNDIS de la LUFA, la carte est maintenant détectée comme carte réseau.&lt;br /&gt;
[[Fichier:Ip a.jpg|vignette|ip a où l&#039;on voit la carte réseau (son addresse IP est 21.21.21.21)]]&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ip_a.jpg&amp;diff=7060</id>
		<title>Fichier:Ip a.jpg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Ip_a.jpg&amp;diff=7060"/>
		<updated>2025-01-06T14:18:30Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;ip a où l&#039;on reconnait la carte réseau&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7000</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=7000"/>
		<updated>2024-12-18T10:34:17Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles.&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.|centré|275x275px]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie... On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.|centré|232x232px]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.|centré|337x337px]]&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6999</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6999"/>
		<updated>2024-12-18T10:30:13Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles.&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
[[Fichier:PCB nu.jpg|vignette|PCB en manque de composants.]]&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
[[Fichier:Interrupteur surprise.jpg|vignette|Interrupteur remplacant le jumper à l&#039;arrière.]]&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie...&lt;br /&gt;
On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Pico brase.jpg|vignette|PCB plus en manque de composants.]]&lt;br /&gt;
Mise à part ce soucis, tout est en ordre et la carte est brasée.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Pico_brase.jpg&amp;diff=6998</id>
		<title>Fichier:Pico brase.jpg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Pico_brase.jpg&amp;diff=6998"/>
		<updated>2024-12-18T10:28:13Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;PCB avec ses composants brasés&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Interrupteur_surprise.jpg&amp;diff=6997</id>
		<title>Fichier:Interrupteur surprise.jpg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Interrupteur_surprise.jpg&amp;diff=6997"/>
		<updated>2024-12-18T10:26:08Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Interrupteur rajouté à l&#039;arrière qui remplace le jumper.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:PCB_nu.jpg&amp;diff=6996</id>
		<title>Fichier:PCB nu.jpg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:PCB_nu.jpg&amp;diff=6996"/>
		<updated>2024-12-18T10:24:12Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;PCB en manque de composants&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6995</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6995"/>
		<updated>2024-12-18T10:04:35Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles.&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
[...]&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;br /&gt;
&lt;br /&gt;
=== Brasure ===&lt;br /&gt;
Le PCB de la Pipelette v1 est arrivée, on peut donc aller braser sans plus tarder.&lt;br /&gt;
&lt;br /&gt;
La brasure se passe bien sauf au moment où l&#039;on a remarqué qu&#039;on a confondu l&#039;empreinte du jumper avec celle d&#039;un connecteur de batterie...&lt;br /&gt;
On a rattrapé l&#039;erreur en brasant un interupteur à l&#039;arrière de la carte.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6884</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6884"/>
		<updated>2024-11-27T11:21:15Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles.&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r5 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r6 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r7 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r8 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r9 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r10 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r11 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r12 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r13 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r14 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r15 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r16 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r17 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r18 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r19 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r20 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r21 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r22 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r23 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r24 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r25 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r26 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r27 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r28 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r29 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r28 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r27 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r26 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r25 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r24 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r23 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r22 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r21 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r20 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r19 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r18 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r17 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r16 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r15 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r14 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r13 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r12 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r11 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r10 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r9 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r8 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r7 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r6 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r5 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r4 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est endormie, on l&#039;ignore et on regarde l&#039;état de la prochaine jusqu&#039;à avoir une tache éveillée.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6883</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6883"/>
		<updated>2024-11-27T11:18:45Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles.&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test carte SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier si le lecteur est fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segments pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause du défaut de conception, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
===Ordonnanceur :===&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur (No Naked):&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Le principe de l&#039;ordonnanceur est de simuler une exécution en parallèle des tâches.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Pour cela, on génère un minuteur qui va nous donner une durée d&#039;exécution d&#039;un programme avant que ce-dernier ne se fasse interrompre pour qu&#039;une autre tâche s&#039;exécute.&lt;br /&gt;
&lt;br /&gt;
Lorsqu&#039;une tâche précédemment interrompue se réexécute, elle reprend là où elle en était dans son processus.&lt;br /&gt;
&lt;br /&gt;
Ici la fonction d&#039;interruption ISR fait clignoter les LEDs lors d&#039;une interruption, la fonction sei() active les interruptions.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, nous allons utiliser l&#039;ISR en mode Naked, c&#039;est-à-dire qu&#039;il ne gère plus la sauvegarde et la restauration du contexte des tâches lors de leur interruption.&lt;br /&gt;
&lt;br /&gt;
Pour commencer, nous avons écrit le bout de code qui sauvegarde le contexte sur la pile et celui qui le restaure.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define portSAVE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;in r0, __SREG__ \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r4 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r5 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r6 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r7 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r8 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r9 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r10 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r11 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r12 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r13 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r14 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r15 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r16 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r17 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r18 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r19 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r20 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r21 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r22 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r23 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r24 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r25 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r26 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r27 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r28 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r29 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;push r31 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define portRESTORE_REGISTER() \&lt;br /&gt;
asm volatile ( \&lt;br /&gt;
&amp;quot;pop r31 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r30 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r29 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r28 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r27 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r26 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r25 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r24 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r23 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r22 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r21 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r20 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r19 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r18 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r17 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r16 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r15 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r14 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r13 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r12 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r11 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r10 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r9 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r8 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r7 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r6 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r5 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r4 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r3 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r2 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r1 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;out __SREG__, r0 \n\t&amp;quot; \&lt;br /&gt;
&amp;quot;pop r0 \n\t&amp;quot; \&lt;br /&gt;
);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED){    // Procédure d&#039;interruption&lt;br /&gt;
  portSAVE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  scheduler();&lt;br /&gt;
&lt;br /&gt;
  portRESTORE_REGISTER();&lt;br /&gt;
&lt;br /&gt;
  asm volatile ( &amp;quot;reti&amp;quot; );&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Puis, nous avons créé une structure de processus, pour que chaque processus soit décrit par un pointeur de fonction, un StackPointer et un état (fini ou en cours).&lt;br /&gt;
&lt;br /&gt;
Afin de pouvoir créer un tableau de processus en global. De plus, on initialise une variable globale &amp;quot;Cprocess&amp;quot; qui représente le processus courant. &amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
tab_process_t tab_process[NB_PROCESS];&lt;br /&gt;
uint8_t Cprocess=0;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ensuite, nous avons séparé le programme de clignotement des LEDs en 5 programmes, 1 pour chaque LED. Et les programmes sont appelés par le scheduler chacun leur tour. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Led1(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00000001;&lt;br /&gt;
    _delay_ms(100);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led2(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00000010;&lt;br /&gt;
    _delay_ms(200);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led3(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTC ^= 0b00001000;&lt;br /&gt;
    _delay_ms(300);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led4(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b00010000;&lt;br /&gt;
    _delay_ms(400);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void Led5(void)&lt;br /&gt;
{&lt;br /&gt;
  while (1)&lt;br /&gt;
  {&lt;br /&gt;
    PORTD ^= 0b10000000;&lt;br /&gt;
    _delay_ms(500);&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi fait une fonction d&#039;initialisation des piles d&#039;exécution des programmes qui seront lancés après la première interruption.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void InitialisationPile(int Cprocess){&lt;br /&gt;
    int save = SP;&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    uint16_t address = (uint16_t)tab_process[Cprocess].process_add;&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; (address &amp;amp; 0x00ff) );&lt;br /&gt;
    asm volatile(&amp;quot;push %0&amp;quot; : : &amp;quot;r&amp;quot; ((address &amp;amp; 0xff00)&amp;gt;&amp;gt;8) );&lt;br /&gt;
    portSAVE_REGISTER();&lt;br /&gt;
    tab_process[Cprocess].StackPointer = SP;&lt;br /&gt;
    SP = save;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Il ne reste plus qu&#039;à faire le setup, associer un processus à un emplacement du tableau de processus; lui associer une adresse de StackPointer et un état, démarrer le minuteur, mettre en place les entrées/sorties , initialiser les piles puis activer les interruptions .&lt;br /&gt;
&lt;br /&gt;
Finalement, on peut lancer la première tâche.&lt;br /&gt;
&lt;br /&gt;
Avec la façon dont nous avons organisé le scheduler, l&#039;ordonnanceur fonctionne en tourniquet.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[0].process_add = Led1;&lt;br /&gt;
    tab_process[1].process_add = Led2;&lt;br /&gt;
    tab_process[2].process_add = Led3;&lt;br /&gt;
    tab_process[3].process_add = Led4;&lt;br /&gt;
    tab_process[4].process_add = Led5;&lt;br /&gt;
    tab_process[0].StackPointer = 0x6ff;&lt;br /&gt;
    tab_process[1].StackPointer = 0x680;&lt;br /&gt;
    tab_process[2].StackPointer = 0x5ff;&lt;br /&gt;
    tab_process[3].StackPointer = 0x580;&lt;br /&gt;
    tab_process[4].StackPointer = 0x4ff;&lt;br /&gt;
    tab_process[0].state = 0;&lt;br /&gt;
    tab_process[1].state = 0;&lt;br /&gt;
    tab_process[2].state = 0;&lt;br /&gt;
    tab_process[3].state = 0;&lt;br /&gt;
    tab_process[4].state = 0;&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    InitialisationPile(1);&lt;br /&gt;
    InitialisationPile(2);&lt;br /&gt;
    InitialisationPile(3);&lt;br /&gt;
    InitialisationPile(4);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    setup();&lt;br /&gt;
    SP = tab_process[Cprocess].StackPointer;&lt;br /&gt;
    tab_process[Cprocess].process_add();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&#039;&#039;&#039;Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
Maintenant, on veut pouvoir endormir des tâches pendant une durée définie. Ces tâches doivent être ignorées par le scheduler.&lt;br /&gt;
&lt;br /&gt;
Pour cela, nous avons rajouté une durée d&#039;endormissement dans la structure tab_process et un programme qui réduit le temps de sommeil à chaque interruption puis un programme qui endort la tâche ciblée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct tab_process{&lt;br /&gt;
                uint16_t StackPointer;&lt;br /&gt;
                void (*process_add)(void);&lt;br /&gt;
              	uint8_t  state;&lt;br /&gt;
                uint16_t sleep;&lt;br /&gt;
                }&lt;br /&gt;
                tab_process_t;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#define TIME_INTERRUPT 20&lt;br /&gt;
&lt;br /&gt;
void DecreaseSleep(void)&lt;br /&gt;
{&lt;br /&gt;
   int nb_sleep = 0;&lt;br /&gt;
   for (uint8_t i=1;i&amp;lt;NB_PROCESS-1;i++)&lt;br /&gt;
   {&lt;br /&gt;
     if (tab_process[i].sleep &amp;gt; 0)&lt;br /&gt;
      {&lt;br /&gt;
        tab_process[i].sleep -= TIME_INTERRUPT;&lt;br /&gt;
        nb_sleep++;&lt;br /&gt;
      }&lt;br /&gt;
   }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setTimeDelay(uint16_t time, uint8_t process)&lt;br /&gt;
{&lt;br /&gt;
  tab_process[process].sleep=time;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Nous avons aussi modifié le scheduler :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On a rajouté une condition au passage à la tâche suivante : si la prochaine tâche est éveillée, on passe la tâche endormie et on exécute celle là. Si la tâche encore d&#039;après n&#039;est pas endormie aussi et ainsi de suite.&lt;br /&gt;
&lt;br /&gt;
On peut repérer un problème : que se passe-t-il si toutes les tâches sont endormies ? On pourrait faire confiance à l&#039;utilisateur en priant pour qu&#039;il n&#039;endorme pas tout le monde mais nous avons préféré ne pas lui faire confiance.&lt;br /&gt;
&lt;br /&gt;
Nous avons donc crée un processus qui est naturellement endormi mais qui se réveille lorsque tout le monde dort, pour éviter une boucle infinie.&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void Anti_sleep_boucle(void)&lt;br /&gt;
{&lt;br /&gt;
  while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// ajoute à setup&lt;br /&gt;
void setup()&lt;br /&gt;
{&lt;br /&gt;
    tab_process[NB_PROCESS-1].process_add = Anti_sleep_boucle;&lt;br /&gt;
    tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
    tab_process[NB_PROCESS-1].StackPointer = 0x3ff;&lt;br /&gt;
    tab_process[NB_PROCESS-1].state = 1;&lt;br /&gt;
}&lt;br /&gt;
 // ajoute à DecreaseSleep &lt;br /&gt;
&lt;br /&gt;
if (nb_sleep ==  NB_PROCESS-2)&lt;br /&gt;
   {&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 0;&lt;br /&gt;
   }&lt;br /&gt;
   else&lt;br /&gt;
     tab_process[NB_PROCESS-1].sleep = 1;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On accorde les autres programmes à Anti_sleep_boucle, on a décidé qu&#039;il sera le dernier processus par soucis de simplicité.[[Fichier:Video des LEDs ordonnancé.mp4|vignette&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void scheduler(void)&lt;br /&gt;
{&lt;br /&gt;
startScheduler:&lt;br /&gt;
   if (Cprocess &amp;lt; NB_PROCESS-1)&lt;br /&gt;
     Cprocess+=1;&lt;br /&gt;
   else&lt;br /&gt;
     Cprocess=1;&lt;br /&gt;
  if (tab_process[Cprocess].sleep &amp;gt; 0)&lt;br /&gt;
  {&lt;br /&gt;
//    scheduler();&lt;br /&gt;
	goto startScheduler;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Video des LEDs ordonnancées|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Bonus :&lt;br /&gt;
&lt;br /&gt;
Nous avons amélioré le makefile donné par Mr Boé l&#039;année dernière :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// modification pour un nettoyer plus efficace&lt;br /&gt;
clean:&lt;br /&gt;
	rm -f *.o&lt;br /&gt;
	rm -f *.hex&lt;br /&gt;
	rm -f *.elf&lt;br /&gt;
// modification pour pouvoir upload directement les modfications sur la carte&lt;br /&gt;
upload: $(TARGET).hex&lt;br /&gt;
	stty -F $(TERM) hupcl # reset&lt;br /&gt;
	avrdude -p atmega328p -c arduino -P /dev/ttyUSB0 \ -b 115200 -D -U flash:w:ordonnanceur.hex:i&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6840</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6840"/>
		<updated>2024-11-20T10:09:02Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : /* Conception */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles.&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
Ordonnanceur UnNaked:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:Video des LEDs ordonnancé.mp4|vignette|Video des LEDs ordonnancé es|centré]]&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper. On a également ajouté des LEDs qui vont servir de témoins lorsqu&#039;il y a communication.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6838</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6838"/>
		<updated>2024-11-20T10:06:26Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles.&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
Ordonnanceur UnNaked:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Ordonnanceur Naked en Round-Robin ( Tourniquet en patois ) :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
Ordonnanceur Naked avec fonction d&#039;endormissement des tâches :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:Video des LEDs ordonnancé.mp4|vignette|Video des LEDs ordonnancé es|centré]]&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
===Conception ===&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]][[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |néant]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6828</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6828"/>
		<updated>2024-11-20T09:56:10Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports He-10 pour y brancher des cartes filles.&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les He-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
sous-partie1 : Ordonnanceur&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;sous-partie2 : Ordonnanceur Naked en Round-Robin ( Tourniquet en patois )&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
sous-partie3 : Ordonnanceur Naked avec fonction d&#039;endormissement des tâches&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:Video des LEDs ordonnancé.mp4|vignette|Video des LEDs ordonnancé es|centré]]&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |gauche]]&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6827</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6827"/>
		<updated>2024-11-20T09:54:54Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
== Shield Arduino ==&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports he-10 pour y brancher des cartes filles.&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les he-10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
sous-partie1 : Ordonnanceur&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;sous-partie2 : Ordonnanceur Naked en Round-Robin ( Tourniquet en patois )&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
sous-partie3 : Ordonnanceur Naked avec fonction d&#039;endormissement des tâches&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:Video des LEDs ordonnancé.mp4|vignette|Video des LEDs ordonnancé es|centré]]&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |gauche]]&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6826</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6826"/>
		<updated>2024-11-20T09:53:37Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports HE10 pour y brancher des cartes filles. &lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges pour avoir assez d&#039;espace pour brancher les HE10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
sous-partie1 : Ordonnanceur&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;sous-partie2 : Ordonnanceur Naked en Round-Robin ( Tourniquet en patois )&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
sous-partie3 : Ordonnanceur Naked avec fonction d&#039;endormissement des tâches&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:Video des LEDs ordonnancé.mp4|vignette|Video des LEDs ordonnancé es|centré]]&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |gauche]]&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6825</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6825"/>
		<updated>2024-11-20T09:52:08Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports HE10 pour y brancher des cartes filles. &lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Petite erreur de conception, la carte a été routée à l&#039;envers... Ce n&#039;est pas catastrophique (un peu quand même) et c&#039;est rattrapable en rajoutant des rallonges donc avoir assez d&#039;espace pour brancher les HE10.&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
sous-partie1 : Ordonnanceur&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/interrupt.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#define CTC1 WGM12&lt;br /&gt;
&lt;br /&gt;
#define PERIODE         1000&lt;br /&gt;
&lt;br /&gt;
ISR(TIMER1_COMPA_vect){    // Procédure d&#039;interruption&lt;br /&gt;
int led1=(PORTC &amp;amp; 0x0f);&lt;br /&gt;
led1 &amp;gt;&amp;gt;= 1; if(led1==0) led1=0b00001001;&lt;br /&gt;
PORTC &amp;amp;= 0xf0; PORTC |= led1;&lt;br /&gt;
&lt;br /&gt;
int led2=(PORTD &amp;amp; 0x0f);&lt;br /&gt;
led2 &amp;gt;&amp;gt;= 1; if(led2==0) led2=0b10010010;&lt;br /&gt;
PORTD &amp;amp;= 0xf0; PORTD |= led2;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
void init_minuteur(int diviseur,long periode){&lt;br /&gt;
TCCR1A=0;               // Le mode choisi n&#039;utilise pas ce registre&lt;br /&gt;
TCCR1B=(1&amp;lt;&amp;lt;CTC1);       // Réinitialisation du minuteur sur expiration&lt;br /&gt;
switch(diviseur){&lt;br /&gt;
  case    8: TCCR1B |= (1&amp;lt;&amp;lt;CS11); break;&lt;br /&gt;
  case   64: TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
  case  256: TCCR1B |= (1&amp;lt;&amp;lt;CS12); break;&lt;br /&gt;
  case 1024: TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10); break;&lt;br /&gt;
}&lt;br /&gt;
// Un cycle prend 1/F_CPU secondes.&lt;br /&gt;
// Un pas de compteur prend diviseur/F_CPU secondes.&lt;br /&gt;
// Pour une periode en millisecondes, il faut (periode/1000)/(diviseur/F_CPU) pas&lt;br /&gt;
// soit (periode*F_CPU)/(1000*diviseur)&lt;br /&gt;
OCR1A=F_CPU/1000*periode/diviseur;  // Calcul du pas&lt;br /&gt;
TCNT1=0;                // Compteur initialisé&lt;br /&gt;
TIMSK1=(1&amp;lt;&amp;lt;OCIE1A);     // Comparaison du compteur avec OCR1A&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
    init_minuteur(1024,PERIODE);&lt;br /&gt;
    DDRC |= 0b00001001;&lt;br /&gt;
    DDRD |= 0b10010010;&lt;br /&gt;
    PORTC &amp;amp;= ~0b00001001;&lt;br /&gt;
    PORTD &amp;amp;= ~0b10010010;&lt;br /&gt;
    init_minuteur(256,PERIODE);&lt;br /&gt;
    sei();    // Autorisation des interruptions&lt;br /&gt;
    while(1);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;sous-partie2 : Ordonnanceur Naked en Round-Robin ( Tourniquet en patois )&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
sous-partie3 : Ordonnanceur Naked avec fonction d&#039;endormissement des tâches&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:Video des LEDs ordonnancé.mp4|vignette|Video des LEDs ordonnancé es|centré]]&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |gauche]]&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6823</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6823"/>
		<updated>2024-11-20T09:46:43Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Le shield va nous permettre de tester nos cartes filles sans la carte mère du Pico. Pour faire nos tests, le shield doit posséder un lecteur de carte SD pour tester la mémoire, des LEDs pour tester des processus et des ports HE10 pour y brancher des cartes filles. &lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons tester les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
sous-partie1 : Ordonnanceur&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;sous-partie2 : Ordonnanceur Naked en Round-Robin ( Tourniquet en patois )&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
sous-partie3 : Ordonnanceur Naked avec fonction d&#039;endormissement des tâches&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot; start=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
bonjour&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[Fichier:Video des LEDs ordonnancé.mp4|vignette|Video des LEDs ordonnancé es|centré]]&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |gauche]]&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6722</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6722"/>
		<updated>2024-11-18T10:14:44Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |gauche]]&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6721</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6721"/>
		<updated>2024-11-18T10:14:05Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |gauche]]&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6719</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6719"/>
		<updated>2024-11-18T10:13:14Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |gauche]]&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6718</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6718"/>
		<updated>2024-11-18T10:12:47Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Kicad CReseau PCB.svg|vignette|Schéma du PCB |gauche]]&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6716</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6716"/>
		<updated>2024-11-18T10:11:48Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:Kicad CReseau PCB.svg|centré|vignette|Schéma du PCB ]]&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau|centré]]&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Kicad_CReseau_PCB.svg&amp;diff=6714</id>
		<title>Fichier:Kicad CReseau PCB.svg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Kicad_CReseau_PCB.svg&amp;diff=6714"/>
		<updated>2024-11-18T10:10:51Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;PCB de la carte&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6703</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6703"/>
		<updated>2024-11-18T09:58:54Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : Description + Schématique CReseau&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau. Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287 car il a une plus grande capacité de stockage que l&#039;AtMega32u4. La carte communiquera avec l&#039;extérieur par mini USB et pourra être alimenté de deux manières différentes: Soit par la carte mère ou soit par le port USB directement grâce à un jumper.&lt;br /&gt;
[[Fichier:SVG Kicad CReseau.svg|vignette|Schématique de la carte réseau]]&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:SVG_Kicad_CReseau.svg&amp;diff=6700</id>
		<title>Fichier:SVG Kicad CReseau.svg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:SVG_Kicad_CReseau.svg&amp;diff=6700"/>
		<updated>2024-11-18T09:57:32Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Schéma en SVG de la carte réseau&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6684</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6684"/>
		<updated>2024-11-18T09:38:19Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
Projet Kicad:[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau du projet PICO-Ordinateur.&lt;br /&gt;
Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287.&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6682</id>
		<title>SE4Binome2024-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2024-4&amp;diff=6682"/>
		<updated>2024-11-18T09:37:34Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : ajout fichier kicad creseau&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Shield Arduino ==&lt;br /&gt;
Lien du GIT : https://gitea.plil.fr/jwacquet/Pico_Binome4_Justin_Ibrahim.git&lt;br /&gt;
&lt;br /&gt;
Projet Kicad : [[Fichier:Projet Kicad Shield.zip|vignette|Projet Kicad Shield Compressé]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Carte Shield Soudé :==== &lt;br /&gt;
[[Fichier:Carte shield soudée face .jpg|vignette|Carte shield soudée face |centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Maintenant que la carte est soudé nous devons les différents éléments de la carte.&lt;br /&gt;
&lt;br /&gt;
====Test LED :====&lt;br /&gt;
&lt;br /&gt;
Pour tester les Leds nous avons réalisé un programme sur arduino qui allume les Leds. &lt;br /&gt;
[[Fichier:VID 20241015 151605(1).mp4|vignette|Vidéo du test des Leds|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test cart SD :====&lt;br /&gt;
&lt;br /&gt;
Nous avons placé la carte SD dans le lecteur puis nous avons utilisé le programme info-carte sur l&#039;IDE Arduino pour vérifier que le lecteur était fonctionnel.&lt;br /&gt;
[[Fichier:Test du lecteur de carte SD.png|vignette|Capture d&#039;écran de l&#039;IDE Arduino lors du test du lecteur de carte SD|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
====Test Port He-10 : ====&lt;br /&gt;
&lt;br /&gt;
Pour tester les ports He-10, nous avons connecté un afficheur 7-segment pour vérifier qu&#039;ils fonctionnent.&lt;br /&gt;
[[Fichier:Video de test des ports HE-10.mp4|vignette|Video de test d&#039;un port HE-10|centré]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malgré des difficultés à connecter les afficheurs 7-segments à cause de défaut de conceptions, les 5 ports HE-10 sont fonctionnels.&lt;br /&gt;
&lt;br /&gt;
====Ordonnanceur :====&lt;br /&gt;
[[Fichier:Ordonnanceur tourniquet .mp4|centré|vignette|Video de démonstration de l&#039;ordonnanceur en tourniquet ]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Carte Réseau ==&lt;br /&gt;
[[Fichier:Kicad CReseau.zip|vignette|Fichier Kicad de la carte réseau RNDIS]]&lt;br /&gt;
Projet Kicad :&lt;br /&gt;
&lt;br /&gt;
=== Introduction ===&lt;br /&gt;
&lt;br /&gt;
Nous allons réaliser la carte fille réseau du projet PICO-Ordinateur.&lt;br /&gt;
Nous avons décidé de partir sur la carte RNDIS, avec un AT90USB1287.&lt;br /&gt;
&lt;br /&gt;
=== Bilan de puissance ===&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Suite à une demande de la part de l&#039;équipe Mère, nous allons effectuer un bilan de puissance de notre carte :&lt;br /&gt;
&lt;br /&gt;
Le composant majeur de notre carte est le microprocesseur, l&#039;AT90USB.&lt;br /&gt;
[[Fichier:Carte d&#039;écran du courant de l&#039;AT90USB.png|centré|vignette|500x500px|Carte d&#039;écran du courant de l&#039;AT90USB]]&lt;br /&gt;
Avec un tension d&#039;entrée de 5V et une fréquence de 16MHz, le microprocesseur consomme : 0,030A x 5V =0,15 W.&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Kicad_CReseau.zip&amp;diff=6681</id>
		<title>Fichier:Kicad CReseau.zip</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Kicad_CReseau.zip&amp;diff=6681"/>
		<updated>2024-11-18T09:36:26Z</updated>

		<summary type="html">&lt;p&gt;Itepeli : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Fichier Kicad de la carte réseau RNDIS&lt;/div&gt;</summary>
		<author><name>Itepeli</name></author>
	</entry>
</feed>