<?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=Tnave</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=Tnave"/>
	<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php/Sp%C3%A9cial:Contributions/Tnave"/>
	<updated>2026-11-18T21:04:49Z</updated>
	<subtitle>Contributions</subtitle>
	<generator>MediaWiki 1.39.1</generator>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2947</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2947"/>
		<updated>2024-01-17T16:40:10Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus en simultanée. Parmi les différents processus, il y aura par exemple la lecture et l&#039;écriture sur le port série ou bien un affichage sur une matrice de LED.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
&lt;br /&gt;
==== Création de l&#039;ordonnanceur ====&lt;br /&gt;
Maintenant que le shield que nous souhaitons utilisé est fonctionnel, nous pouvons passer à la partie programmation de la carte en commençant par gérer les interruptions avec notre minuteur.&lt;br /&gt;
&lt;br /&gt;
Il faut que toutes les X ms la fonction d&#039;interruption se lance afin de sauvegarder le contexte de la tache mais aussi pour passer à la tache suivante. Pour cela, nous avons commencer par créer le minuteur puis nous avons créer la fonction d&#039;interruption faisant appel à la fonction ordonnanceur :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction Minuteur&lt;br /&gt;
!ISR&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_timer()&lt;br /&gt;
{&lt;br /&gt;
TCCR1A = 0;  // No output pin connected, no PWM mode enabled&lt;br /&gt;
TCCR1B = 1&amp;lt;&amp;lt;CTC1; // No input pin used, clear timer counter on compare match&lt;br /&gt;
#if (PRESCALER==8)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==64)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==256)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==1024)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
OCR1A = NB_TICK;&lt;br /&gt;
TCNT1 = 0;&lt;br /&gt;
TIMSK1 = (1&amp;lt;&amp;lt;OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED)&lt;br /&gt;
{&lt;br /&gt;
  /* Sauvegarde du contexte de la tâche interrompue */&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[courant].SPointeur = SP;&lt;br /&gt;
  /* Appel à l&#039;ordonnanceur */&lt;br /&gt;
  ordonnanceur();&lt;br /&gt;
&lt;br /&gt;
  /* Récupération du contexte de la tâche ré-activée */&lt;br /&gt;
  SP = ListeTaches[courant].SPointeur;&lt;br /&gt;
  RESTORE_REGISTER();&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;
&lt;br /&gt;
==== Création des différentes taches ====&lt;br /&gt;
Pour créer une taches, nous avons créer une structure comprennant l&#039;action à réaliser ainsi que le Stack Pointer attribuer à cette tache ( par la suite, on gèrera également l&#039;état d&#039;une tache ainsi que la durée de l&#039;état SLEEP ci c&#039;est le cas ) &lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Structure d&#039;une tache&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
struct Tache{&lt;br /&gt;
  void (*fonction)(void);&lt;br /&gt;
  uint16_t SPointeur;&lt;br /&gt;
  int etat;&lt;br /&gt;
  int duree;&lt;br /&gt;
  uint8_t raison;&lt;br /&gt;
};&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
Attention, avant toute chose, il faut penser à initialiser le contexte des taches pour éviter les problèmes liés à la pile. Pour cela, nous avons fait une fonction qui initialise toutes les taches présentent avant le lancement :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Initialisation des taches&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_tache(int N)&lt;br /&gt;
{&lt;br /&gt;
  int saveSP = SP;&lt;br /&gt;
  SP = ListeTaches[N].SPointeur;&lt;br /&gt;
  uint16_t adresse = (uint16_t)ListeTaches[N].fonction;&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; (adresse &amp;amp; 0x00ff));&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; ((adresse &amp;amp; 0xff00) &amp;gt;&amp;gt; 8));&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[N].SPointeur = SP;&lt;br /&gt;
  SP = saveSP;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
On retrouvera l&#039;ensemble des taches dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/fonction.c fonction.c]&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Première étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Deuxième étape &amp;lt;/u&amp;gt;:&#039;&#039;&#039; Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
Pour ajouter les états ACTIF et SLEEP, nous avons écrit la fonction delay() qui met une tache en SLEEP pour une durée donnée ( pour remplacer _delay_ms() ).&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction delay &lt;br /&gt;
!Ordonnanceur&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void delay(int ms)&lt;br /&gt;
{&lt;br /&gt;
  cli();&lt;br /&gt;
  ListeTaches[courant].etat = ETAT_SLEEP;&lt;br /&gt;
  ListeTaches[courant].raison = DELAY;&lt;br /&gt;
  ListeTaches[courant].duree = ms;&lt;br /&gt;
  TCNT1 = 0;&lt;br /&gt;
  sei();&lt;br /&gt;
  TIMER1_COMPA_vect();&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ordonnanceur()&lt;br /&gt;
{&lt;br /&gt;
  for(int i=0; i&amp;lt;NBR_TACHE; i++)&lt;br /&gt;
    {&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == DELAY)&lt;br /&gt;
	{&lt;br /&gt;
	  uint16_t time_ms=20;&lt;br /&gt;
	  if(TCNT1 != 0)&lt;br /&gt;
	    {&lt;br /&gt;
	      time_ms = TCNT1*200/OCR1A/10;&lt;br /&gt;
	      TCNT1 = 0;&lt;br /&gt;
	    }&lt;br /&gt;
	  ListeTaches[i].duree = ListeTaches[i].duree-time_ms;&lt;br /&gt;
	  if(ListeTaches[i].duree &amp;lt;= 0)&lt;br /&gt;
	    ListeTaches[i].etat = ETAT_ACTIF;&lt;br /&gt;
	}&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == ECRITURE &amp;amp;&amp;amp; sem_ecriture &amp;gt; 0)&lt;br /&gt;
	ListeTaches[courant].etat = ETAT_ACTIF;&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == LECTURE &amp;amp;&amp;amp; sem_lecture &amp;gt; 0)&lt;br /&gt;
      ListeTaches[courant].etat = ETAT_ACTIF;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
  do{           //Changement de tache jusqu&#039;a une tache active&lt;br /&gt;
    courant++;&lt;br /&gt;
    if(courant == NBR_TACHE) courant = 0;&lt;br /&gt;
  }&lt;br /&gt;
  while(ListeTaches[courant].etat == ETAT_SLEEP);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
De plus, nous avons effectuer des modifications au sein de l&#039;ordonnanceur pour ne prendre en compte que les taches ACTIF ( il y a une tache &amp;quot;zombie&amp;quot; afin de ne pas bloquer le programme ) .&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Troisième étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : on retrouvera le code dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/USART.c USART.c]&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Quatrième étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Gestion de la matrice de LED avec la lecture sur port USB : on retrouvera le code dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/SPI_matrice.c SPI_matrice.c]&lt;br /&gt;
Voici une vidéo montrant une lecture de caractère sur minicom ainsi que l&#039;affichage avec la matrice LED[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : on retrouvera le code dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/SPI_7seg.c SPI_7seg.c]&lt;br /&gt;
Voici une vidéo montrant une lecture de caractère sur minicom ainsi que l&#039;affichage avec l&#039;afficheur 7-segements[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
==== Précision : ====&lt;br /&gt;
- Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
- Pour ajouter ou retirer une taches, il faut penser à la mettre en commentaire dans le tableau regroupant les taches dans ordonnanceur.c mais il fait aussi penser à modifier NBR_TACHE dans le .h&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons fait en sorte, dans un premier temps, que lorsque notre carte recoit n&#039;importe qu&#039;il paquet ( paquet d&#039;un ping par exemple ) la LED s&#039;allume ou s&#039;éteint.&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
=== Création du protocole ===&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte : le code de l&#039;application se trouve sur [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/RNDIS/Programme/Appli/ether.c ether.c]&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait en sorte que l&#039;application ne lise que les paquets sur notre interface usb0 lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole, nous nous sommes inspiré de la structure du protocole ARP :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
  uint8_t       Operation;&lt;br /&gt;
  MAC_Address_t MAddr_SRC;&lt;br /&gt;
  IP_Address_t  PAddr_SRC;&lt;br /&gt;
  MAC_Address_t MAddr_DESC;&lt;br /&gt;
  IP_Address_t  PAddr_DESC;&lt;br /&gt;
  uint8_t       Longueur;&lt;br /&gt;
  uint8_t       Data[MAX_DATA];&lt;br /&gt;
} Proto_Header_t;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations. L&#039;intégralité du code de notre protocole se trouve sur [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/RNDIS/Programme/RNDISEthernet/Lib/Mon_Proto.c Mon_Proto.c]&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
===== Réception =====&lt;br /&gt;
Pour créer un fichier sur le PC, nous devons : &lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; d&#039;envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.&lt;br /&gt;
&lt;br /&gt;
- Le paquet est ensuite renvoyé sur l&#039;application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Exemple :&lt;br /&gt;
&lt;br /&gt;
Nous envoyons donc notre ordre avec en plus un texte : &amp;quot;Test Envoi :&amp;quot; --&amp;gt; Avec l&#039;application pas avec la carte mère&lt;br /&gt;
[[Fichier:Envoi.png|néant|vignette|Paquet envoyé par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : &amp;quot; Ajout par la carte&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Elle envoie donc le paquet modifié à l&#039;application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.&lt;br /&gt;
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons donc un fichier qui contient le texte : &amp;quot;Test Envoi : Ajout par la carte&amp;quot;.&lt;br /&gt;
[[Fichier:Recept.png|néant|vignette|Contenu du fichier]]&lt;br /&gt;
&lt;br /&gt;
===== Lecture =====&lt;br /&gt;
Pour lire un fichier sur le PC, nous devons:&lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; de lire un fichier (0x02) --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d&#039;ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l&#039;application&lt;br /&gt;
&lt;br /&gt;
- L&#039;application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --&amp;gt; a envoyer à la carte mère.&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
Nous avons réussi à accomplir :&lt;br /&gt;
&lt;br /&gt;
- Ordonnanceur avec les états SLEEP et ACTIF&lt;br /&gt;
&lt;br /&gt;
- Les taches concernant le port série&lt;br /&gt;
&lt;br /&gt;
- Les taches concernant le bus SPI ( Il aurait aussi fallu créer une tache supplémentaire pour &amp;quot;partager&amp;quot; le bus SPI )&lt;br /&gt;
&lt;br /&gt;
- La conception de notre carte RNDIS&lt;br /&gt;
&lt;br /&gt;
- Un début de protocole réseau permettant d&#039;effectuer des échanges entre la carte et l&#039;application&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Malheureusement, notre carte ne peut pas être connecté à la carte mère car il n&#039;y a pas les différentes primitives&lt;br /&gt;
&lt;br /&gt;
Avec plus de temps, nous aurions peut-être pu terminer les fonctions de lecture et de listage des fichiers mais aussi les primitives pour intégrer notre carte fille à la carte mère&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2945</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2945"/>
		<updated>2024-01-17T16:31:43Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Création du protocole */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus en simultanée. Parmi les différents processus, il y aura par exemple la lecture et l&#039;écriture sur le port série ou bien un affichage sur une matrice de LED.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
&lt;br /&gt;
==== Création de l&#039;ordonnanceur ====&lt;br /&gt;
Maintenant que le shield que nous souhaitons utilisé est fonctionnel, nous pouvons passer à la partie programmation de la carte en commençant par gérer les interruptions avec notre minuteur.&lt;br /&gt;
&lt;br /&gt;
Il faut que toutes les X ms la fonction d&#039;interruption se lance afin de sauvegarder le contexte de la tache mais aussi pour passer à la tache suivante. Pour cela, nous avons commencer par créer le minuteur puis nous avons créer la fonction d&#039;interruption faisant appel à la fonction ordonnanceur :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction Minuteur&lt;br /&gt;
!ISR&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_timer()&lt;br /&gt;
{&lt;br /&gt;
TCCR1A = 0;  // No output pin connected, no PWM mode enabled&lt;br /&gt;
TCCR1B = 1&amp;lt;&amp;lt;CTC1; // No input pin used, clear timer counter on compare match&lt;br /&gt;
#if (PRESCALER==8)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==64)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==256)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==1024)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
OCR1A = NB_TICK;&lt;br /&gt;
TCNT1 = 0;&lt;br /&gt;
TIMSK1 = (1&amp;lt;&amp;lt;OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED)&lt;br /&gt;
{&lt;br /&gt;
  /* Sauvegarde du contexte de la tâche interrompue */&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[courant].SPointeur = SP;&lt;br /&gt;
  /* Appel à l&#039;ordonnanceur */&lt;br /&gt;
  ordonnanceur();&lt;br /&gt;
&lt;br /&gt;
  /* Récupération du contexte de la tâche ré-activée */&lt;br /&gt;
  SP = ListeTaches[courant].SPointeur;&lt;br /&gt;
  RESTORE_REGISTER();&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;
&lt;br /&gt;
==== Création des différentes taches ====&lt;br /&gt;
Pour créer une taches, nous avons créer une structure comprennant l&#039;action à réaliser ainsi que le Stack Pointer attribuer à cette tache ( par la suite, on gèrera également l&#039;état d&#039;une tache ainsi que la durée de l&#039;état SLEEP ci c&#039;est le cas ) &lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Structure d&#039;une tache&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
struct Tache{&lt;br /&gt;
  void (*fonction)(void);&lt;br /&gt;
  uint16_t SPointeur;&lt;br /&gt;
  int etat;&lt;br /&gt;
  int duree;&lt;br /&gt;
  uint8_t raison;&lt;br /&gt;
};&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
Attention, avant toute chose, il faut penser à initialiser le contexte des taches pour éviter les problèmes liés à la pile. Pour cela, nous avons fait une fonction qui initialise toutes les taches présentent avant le lancement :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Initialisation des taches&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_tache(int N)&lt;br /&gt;
{&lt;br /&gt;
  int saveSP = SP;&lt;br /&gt;
  SP = ListeTaches[N].SPointeur;&lt;br /&gt;
  uint16_t adresse = (uint16_t)ListeTaches[N].fonction;&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; (adresse &amp;amp; 0x00ff));&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; ((adresse &amp;amp; 0xff00) &amp;gt;&amp;gt; 8));&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[N].SPointeur = SP;&lt;br /&gt;
  SP = saveSP;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
On retrouvera l&#039;ensemble des taches dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/fonction.c fonction.c]&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Première étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Deuxième étape &amp;lt;/u&amp;gt;:&#039;&#039;&#039; Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
Pour ajouter les états ACTIF et SLEEP, nous avons écrit la fonction delay() qui met une tache en SLEEP pour une durée donnée ( pour remplacer _delay_ms() ).&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction delay &lt;br /&gt;
!Ordonnanceur&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void delay(int ms)&lt;br /&gt;
{&lt;br /&gt;
  cli();&lt;br /&gt;
  ListeTaches[courant].etat = ETAT_SLEEP;&lt;br /&gt;
  ListeTaches[courant].raison = DELAY;&lt;br /&gt;
  ListeTaches[courant].duree = ms;&lt;br /&gt;
  TCNT1 = 0;&lt;br /&gt;
  sei();&lt;br /&gt;
  TIMER1_COMPA_vect();&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ordonnanceur()&lt;br /&gt;
{&lt;br /&gt;
  for(int i=0; i&amp;lt;NBR_TACHE; i++)&lt;br /&gt;
    {&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == DELAY)&lt;br /&gt;
	{&lt;br /&gt;
	  uint16_t time_ms=20;&lt;br /&gt;
	  if(TCNT1 != 0)&lt;br /&gt;
	    {&lt;br /&gt;
	      time_ms = TCNT1*200/OCR1A/10;&lt;br /&gt;
	      TCNT1 = 0;&lt;br /&gt;
	    }&lt;br /&gt;
	  ListeTaches[i].duree = ListeTaches[i].duree-time_ms;&lt;br /&gt;
	  if(ListeTaches[i].duree &amp;lt;= 0)&lt;br /&gt;
	    ListeTaches[i].etat = ETAT_ACTIF;&lt;br /&gt;
	}&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == ECRITURE &amp;amp;&amp;amp; sem_ecriture &amp;gt; 0)&lt;br /&gt;
	ListeTaches[courant].etat = ETAT_ACTIF;&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == LECTURE &amp;amp;&amp;amp; sem_lecture &amp;gt; 0)&lt;br /&gt;
      ListeTaches[courant].etat = ETAT_ACTIF;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
  do{           //Changement de tache jusqu&#039;a une tache active&lt;br /&gt;
    courant++;&lt;br /&gt;
    if(courant == NBR_TACHE) courant = 0;&lt;br /&gt;
  }&lt;br /&gt;
  while(ListeTaches[courant].etat == ETAT_SLEEP);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
De plus, nous avons effectuer des modifications au sein de l&#039;ordonnanceur pour ne prendre en compte que les taches ACTIF ( il y a une tache &amp;quot;zombie&amp;quot; afin de ne pas bloquer le programme ) .&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Troisième étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : on retrouvera le code dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/USART.c USART.c]&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Quatrième étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Gestion de la matrice de LED avec la lecture sur port USB : on retrouvera le code dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/SPI_matrice.c SPI_matrice.c]&lt;br /&gt;
Voici une vidéo montrant une lecture de caractère sur minicom ainsi que l&#039;affichage avec la matrice LED[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : on retrouvera le code dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/SPI_7seg.c SPI_7seg.c]&lt;br /&gt;
Voici une vidéo montrant une lecture de caractère sur minicom ainsi que l&#039;affichage avec l&#039;afficheur 7-segements[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
==== Précision : ====&lt;br /&gt;
- Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
- Pour ajouter ou retirer une taches, il faut penser à la mettre en commentaire dans le tableau regroupant les taches dans ordonnanceur.c mais il fait aussi penser à modifier NBR_TACHE dans le .h&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons fait en sorte, dans un premier temps, que lorsque notre carte recoit n&#039;importe qu&#039;il paquet ( paquet d&#039;un ping par exemple ) la LED s&#039;allume ou s&#039;éteint.&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
=== Création du protocole ===&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte : le code de l&#039;application se trouve sur [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/RNDIS/Programme/Appli/ether.c ether.c]&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait en sorte que l&#039;application ne lise que les paquets sur notre interface usb0 lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole, nous nous sommes inspiré de la structure du protocole ARP :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
  uint8_t       Operation;&lt;br /&gt;
  MAC_Address_t MAddr_SRC;&lt;br /&gt;
  IP_Address_t  PAddr_SRC;&lt;br /&gt;
  MAC_Address_t MAddr_DESC;&lt;br /&gt;
  IP_Address_t  PAddr_DESC;&lt;br /&gt;
  uint8_t       Longueur;&lt;br /&gt;
  uint8_t       Data[MAX_DATA];&lt;br /&gt;
} Proto_Header_t;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations. L&#039;intégralité du code de notre protocole se trouve sur [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/RNDIS/Programme/RNDISEthernet/Lib/Mon_Proto.c Mon_Proto.c]&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
===== Réception =====&lt;br /&gt;
Pour créer un fichier sur le PC, nous devons : &lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; d&#039;envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.&lt;br /&gt;
&lt;br /&gt;
- Le paquet est ensuite renvoyé sur l&#039;application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Exemple :&lt;br /&gt;
&lt;br /&gt;
Nous envoyons donc notre ordre avec en plus un texte : &amp;quot;Test Envoi :&amp;quot; --&amp;gt; Avec l&#039;application pas avec la carte mère&lt;br /&gt;
[[Fichier:Envoi.png|néant|vignette|Paquet envoyé par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : &amp;quot; Ajout par la carte&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Elle envoie donc le paquet modifié à l&#039;application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.&lt;br /&gt;
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons donc un fichier qui contient le texte : &amp;quot;Test Envoi : Ajout par la carte&amp;quot;.&lt;br /&gt;
[[Fichier:Recept.png|néant|vignette|Contenu du fichier]]&lt;br /&gt;
&lt;br /&gt;
===== Lecture =====&lt;br /&gt;
Pour lire un fichier sur le PC, nous devons:&lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; de lire un fichier (0x02) --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d&#039;ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l&#039;application&lt;br /&gt;
&lt;br /&gt;
- L&#039;application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --&amp;gt; a envoyer à la carte mère.&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2942</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2942"/>
		<updated>2024-01-17T16:19:55Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Création des différentes taches */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus en simultanée. Parmi les différents processus, il y aura par exemple la lecture et l&#039;écriture sur le port série ou bien un affichage sur une matrice de LED.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
&lt;br /&gt;
==== Création de l&#039;ordonnanceur ====&lt;br /&gt;
Maintenant que le shield que nous souhaitons utilisé est fonctionnel, nous pouvons passer à la partie programmation de la carte en commençant par gérer les interruptions avec notre minuteur.&lt;br /&gt;
&lt;br /&gt;
Il faut que toutes les X ms la fonction d&#039;interruption se lance afin de sauvegarder le contexte de la tache mais aussi pour passer à la tache suivante. Pour cela, nous avons commencer par créer le minuteur puis nous avons créer la fonction d&#039;interruption faisant appel à la fonction ordonnanceur :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction Minuteur&lt;br /&gt;
!ISR&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_timer()&lt;br /&gt;
{&lt;br /&gt;
TCCR1A = 0;  // No output pin connected, no PWM mode enabled&lt;br /&gt;
TCCR1B = 1&amp;lt;&amp;lt;CTC1; // No input pin used, clear timer counter on compare match&lt;br /&gt;
#if (PRESCALER==8)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==64)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==256)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==1024)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
OCR1A = NB_TICK;&lt;br /&gt;
TCNT1 = 0;&lt;br /&gt;
TIMSK1 = (1&amp;lt;&amp;lt;OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED)&lt;br /&gt;
{&lt;br /&gt;
  /* Sauvegarde du contexte de la tâche interrompue */&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[courant].SPointeur = SP;&lt;br /&gt;
  /* Appel à l&#039;ordonnanceur */&lt;br /&gt;
  ordonnanceur();&lt;br /&gt;
&lt;br /&gt;
  /* Récupération du contexte de la tâche ré-activée */&lt;br /&gt;
  SP = ListeTaches[courant].SPointeur;&lt;br /&gt;
  RESTORE_REGISTER();&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;
&lt;br /&gt;
==== Création des différentes taches ====&lt;br /&gt;
Pour créer une taches, nous avons créer une structure comprennant l&#039;action à réaliser ainsi que le Stack Pointer attribuer à cette tache ( par la suite, on gèrera également l&#039;état d&#039;une tache ainsi que la durée de l&#039;état SLEEP ci c&#039;est le cas ) &lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Structure d&#039;une tache&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
struct Tache{&lt;br /&gt;
  void (*fonction)(void);&lt;br /&gt;
  uint16_t SPointeur;&lt;br /&gt;
  int etat;&lt;br /&gt;
  int duree;&lt;br /&gt;
  uint8_t raison;&lt;br /&gt;
};&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
Attention, avant toute chose, il faut penser à initialiser le contexte des taches pour éviter les problèmes liés à la pile. Pour cela, nous avons fait une fonction qui initialise toutes les taches présentent avant le lancement :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Initialisation des taches&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_tache(int N)&lt;br /&gt;
{&lt;br /&gt;
  int saveSP = SP;&lt;br /&gt;
  SP = ListeTaches[N].SPointeur;&lt;br /&gt;
  uint16_t adresse = (uint16_t)ListeTaches[N].fonction;&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; (adresse &amp;amp; 0x00ff));&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; ((adresse &amp;amp; 0xff00) &amp;gt;&amp;gt; 8));&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[N].SPointeur = SP;&lt;br /&gt;
  SP = saveSP;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
On retrouvera l&#039;ensemble des taches dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/fonction.c fonction.c]&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Première étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Deuxième étape &amp;lt;/u&amp;gt;:&#039;&#039;&#039; Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
Pour ajouter les états ACTIF et SLEEP, nous avons écrit la fonction delay() qui met une tache en SLEEP pour une durée donnée ( pour remplacer _delay_ms() ).&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction delay &lt;br /&gt;
!Ordonnanceur&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void delay(int ms)&lt;br /&gt;
{&lt;br /&gt;
  cli();&lt;br /&gt;
  ListeTaches[courant].etat = ETAT_SLEEP;&lt;br /&gt;
  ListeTaches[courant].raison = DELAY;&lt;br /&gt;
  ListeTaches[courant].duree = ms;&lt;br /&gt;
  TCNT1 = 0;&lt;br /&gt;
  sei();&lt;br /&gt;
  TIMER1_COMPA_vect();&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ordonnanceur()&lt;br /&gt;
{&lt;br /&gt;
  for(int i=0; i&amp;lt;NBR_TACHE; i++)&lt;br /&gt;
    {&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == DELAY)&lt;br /&gt;
	{&lt;br /&gt;
	  uint16_t time_ms=20;&lt;br /&gt;
	  if(TCNT1 != 0)&lt;br /&gt;
	    {&lt;br /&gt;
	      time_ms = TCNT1*200/OCR1A/10;&lt;br /&gt;
	      TCNT1 = 0;&lt;br /&gt;
	    }&lt;br /&gt;
	  ListeTaches[i].duree = ListeTaches[i].duree-time_ms;&lt;br /&gt;
	  if(ListeTaches[i].duree &amp;lt;= 0)&lt;br /&gt;
	    ListeTaches[i].etat = ETAT_ACTIF;&lt;br /&gt;
	}&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == ECRITURE &amp;amp;&amp;amp; sem_ecriture &amp;gt; 0)&lt;br /&gt;
	ListeTaches[courant].etat = ETAT_ACTIF;&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == LECTURE &amp;amp;&amp;amp; sem_lecture &amp;gt; 0)&lt;br /&gt;
      ListeTaches[courant].etat = ETAT_ACTIF;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
  do{           //Changement de tache jusqu&#039;a une tache active&lt;br /&gt;
    courant++;&lt;br /&gt;
    if(courant == NBR_TACHE) courant = 0;&lt;br /&gt;
  }&lt;br /&gt;
  while(ListeTaches[courant].etat == ETAT_SLEEP);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
De plus, nous avons effectuer des modifications au sein de l&#039;ordonnanceur pour ne prendre en compte que les taches ACTIF ( il y a une tache &amp;quot;zombie&amp;quot; afin de ne pas bloquer le programme ) .&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Troisième étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : on retrouvera le code dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/USART.c USART.c]&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Quatrième étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Gestion de la matrice de LED avec la lecture sur port USB : on retrouvera le code dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/SPI_matrice.c SPI_matrice.c]&lt;br /&gt;
Voici une vidéo montrant une lecture de caractère sur minicom ainsi que l&#039;affichage avec la matrice LED[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : on retrouvera le code dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/SPI_7seg.c SPI_7seg.c]&lt;br /&gt;
Voici une vidéo montrant une lecture de caractère sur minicom ainsi que l&#039;affichage avec l&#039;afficheur 7-segements[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
==== Précision : ====&lt;br /&gt;
- Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
- Pour ajouter ou retirer une taches, il faut penser à la mettre en commentaire dans le tableau regroupant les taches dans ordonnanceur.c mais il fait aussi penser à modifier NBR_TACHE dans le .h&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Création du protocole ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
  uint8_t       Operation;&lt;br /&gt;
  MAC_Address_t MAddr_SRC;&lt;br /&gt;
  IP_Address_t  PAddr_SRC;&lt;br /&gt;
  MAC_Address_t MAddr_DESC;&lt;br /&gt;
  IP_Address_t  PAddr_DESC;&lt;br /&gt;
  uint8_t       Longueur;&lt;br /&gt;
  uint8_t       Data[MAX_DATA];&lt;br /&gt;
} Proto_Header_t;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations.&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
===== Réception =====&lt;br /&gt;
Pour créer un fichier sur le PC, nous devons : &lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; d&#039;envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.&lt;br /&gt;
&lt;br /&gt;
- Le paquet est ensuite renvoyé sur l&#039;application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Exemple :&lt;br /&gt;
&lt;br /&gt;
Nous envoyons donc notre ordre avec en plus un texte : &amp;quot;Test Envoi :&amp;quot; --&amp;gt; Avec l&#039;application pas avec la carte mère&lt;br /&gt;
[[Fichier:Envoi.png|néant|vignette|Paquet envoyé par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : &amp;quot; Ajout par la carte&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Elle envoie donc le paquet modifié à l&#039;application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.&lt;br /&gt;
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons donc un fichier qui contient le texte : &amp;quot;Test Envoi : Ajout par la carte&amp;quot;.&lt;br /&gt;
[[Fichier:Recept.png|néant|vignette|Contenu du fichier]]&lt;br /&gt;
&lt;br /&gt;
===== Lecture =====&lt;br /&gt;
Pour lire un fichier sur le PC, nous devons:&lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; de lire un fichier (0x02) --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d&#039;ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l&#039;application&lt;br /&gt;
&lt;br /&gt;
- L&#039;application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --&amp;gt; a envoyer à la carte mère.&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2938</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2938"/>
		<updated>2024-01-17T16:12:14Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Création des différentes taches */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus en simultanée. Parmi les différents processus, il y aura par exemple la lecture et l&#039;écriture sur le port série ou bien un affichage sur une matrice de LED.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
&lt;br /&gt;
==== Création de l&#039;ordonnanceur ====&lt;br /&gt;
Maintenant que le shield que nous souhaitons utilisé est fonctionnel, nous pouvons passer à la partie programmation de la carte en commençant par gérer les interruptions avec notre minuteur.&lt;br /&gt;
&lt;br /&gt;
Il faut que toutes les X ms la fonction d&#039;interruption se lance afin de sauvegarder le contexte de la tache mais aussi pour passer à la tache suivante. Pour cela, nous avons commencer par créer le minuteur puis nous avons créer la fonction d&#039;interruption faisant appel à la fonction ordonnanceur :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction Minuteur&lt;br /&gt;
!ISR&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_timer()&lt;br /&gt;
{&lt;br /&gt;
TCCR1A = 0;  // No output pin connected, no PWM mode enabled&lt;br /&gt;
TCCR1B = 1&amp;lt;&amp;lt;CTC1; // No input pin used, clear timer counter on compare match&lt;br /&gt;
#if (PRESCALER==8)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==64)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==256)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==1024)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
OCR1A = NB_TICK;&lt;br /&gt;
TCNT1 = 0;&lt;br /&gt;
TIMSK1 = (1&amp;lt;&amp;lt;OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED)&lt;br /&gt;
{&lt;br /&gt;
  /* Sauvegarde du contexte de la tâche interrompue */&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[courant].SPointeur = SP;&lt;br /&gt;
  /* Appel à l&#039;ordonnanceur */&lt;br /&gt;
  ordonnanceur();&lt;br /&gt;
&lt;br /&gt;
  /* Récupération du contexte de la tâche ré-activée */&lt;br /&gt;
  SP = ListeTaches[courant].SPointeur;&lt;br /&gt;
  RESTORE_REGISTER();&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;
&lt;br /&gt;
==== Création des différentes taches ====&lt;br /&gt;
Pour créer une taches, nous avons créer une structure comprennant l&#039;action à réaliser ainsi que le Stack Pointer attribuer à cette tache ( par la suite, on gèrera également l&#039;état d&#039;une tache ainsi que la durée de l&#039;état SLEEP ci c&#039;est le cas ) &lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Structure d&#039;une tache&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
struct Tache{&lt;br /&gt;
  void (*fonction)(void);&lt;br /&gt;
  uint16_t SPointeur;&lt;br /&gt;
  int etat;&lt;br /&gt;
  int duree;&lt;br /&gt;
  uint8_t raison;&lt;br /&gt;
};&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
Attention, avant toute chose, il faut penser à initialiser le contexte des taches pour éviter les problèmes liés à la pile. Pour cela, nous avons fait une fonction qui initialise toutes les taches présentent avant le lancement :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Initialisation des taches&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_tache(int N)&lt;br /&gt;
{&lt;br /&gt;
  int saveSP = SP;&lt;br /&gt;
  SP = ListeTaches[N].SPointeur;&lt;br /&gt;
  uint16_t adresse = (uint16_t)ListeTaches[N].fonction;&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; (adresse &amp;amp; 0x00ff));&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; ((adresse &amp;amp; 0xff00) &amp;gt;&amp;gt; 8));&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[N].SPointeur = SP;&lt;br /&gt;
  SP = saveSP;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
On retrouvera l&#039;ensemble des taches dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/fonction.c fonction.c]&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Première étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Deuxième étape &amp;lt;/u&amp;gt;:&#039;&#039;&#039; Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
Pour ajouter les états ACTIF et SLEEP, nous avons écrit la fonction delay() qui met une tache en SLEEP pour une durée donnée ( pour remplacer _delay_ms() ).&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction delay &lt;br /&gt;
!Ordonnanceur&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void delay(int ms)&lt;br /&gt;
{&lt;br /&gt;
  cli();&lt;br /&gt;
  ListeTaches[courant].etat = ETAT_SLEEP;&lt;br /&gt;
  ListeTaches[courant].raison = DELAY;&lt;br /&gt;
  ListeTaches[courant].duree = ms;&lt;br /&gt;
  TCNT1 = 0;&lt;br /&gt;
  sei();&lt;br /&gt;
  TIMER1_COMPA_vect();&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ordonnanceur()&lt;br /&gt;
{&lt;br /&gt;
  for(int i=0; i&amp;lt;NBR_TACHE; i++)&lt;br /&gt;
    {&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == DELAY)&lt;br /&gt;
	{&lt;br /&gt;
	  uint16_t time_ms=20;&lt;br /&gt;
	  if(TCNT1 != 0)&lt;br /&gt;
	    {&lt;br /&gt;
	      time_ms = TCNT1*200/OCR1A/10;&lt;br /&gt;
	      TCNT1 = 0;&lt;br /&gt;
	    }&lt;br /&gt;
	  ListeTaches[i].duree = ListeTaches[i].duree-time_ms;&lt;br /&gt;
	  if(ListeTaches[i].duree &amp;lt;= 0)&lt;br /&gt;
	    ListeTaches[i].etat = ETAT_ACTIF;&lt;br /&gt;
	}&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == ECRITURE &amp;amp;&amp;amp; sem_ecriture &amp;gt; 0)&lt;br /&gt;
	ListeTaches[courant].etat = ETAT_ACTIF;&lt;br /&gt;
      if(ListeTaches[i].etat == ETAT_SLEEP &amp;amp;&amp;amp; ListeTaches[i].raison == LECTURE &amp;amp;&amp;amp; sem_lecture &amp;gt; 0)&lt;br /&gt;
      ListeTaches[courant].etat = ETAT_ACTIF;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
  do{           //Changement de tache jusqu&#039;a une tache active&lt;br /&gt;
    courant++;&lt;br /&gt;
    if(courant == NBR_TACHE) courant = 0;&lt;br /&gt;
  }&lt;br /&gt;
  while(ListeTaches[courant].etat == ETAT_SLEEP);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
De plus, nous avons effectuer des modifications au sein de l&#039;ordonnanceur pour ne prendre en compte que les taches ACTIF ( il y a une tache &amp;quot;zombie&amp;quot; afin de ne pas bloquer le programme ) .&lt;br /&gt;
* &#039;&#039;&#039;&amp;lt;u&amp;gt;Troisième étape :&amp;lt;/u&amp;gt;&#039;&#039;&#039; Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Création du protocole ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
  uint8_t       Operation;&lt;br /&gt;
  MAC_Address_t MAddr_SRC;&lt;br /&gt;
  IP_Address_t  PAddr_SRC;&lt;br /&gt;
  MAC_Address_t MAddr_DESC;&lt;br /&gt;
  IP_Address_t  PAddr_DESC;&lt;br /&gt;
  uint8_t       Longueur;&lt;br /&gt;
  uint8_t       Data[MAX_DATA];&lt;br /&gt;
} Proto_Header_t;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations.&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
===== Réception =====&lt;br /&gt;
Pour créer un fichier sur le PC, nous devons : &lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; d&#039;envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.&lt;br /&gt;
&lt;br /&gt;
- Le paquet est ensuite renvoyé sur l&#039;application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Exemple :&lt;br /&gt;
&lt;br /&gt;
Nous envoyons donc notre ordre avec en plus un texte : &amp;quot;Test Envoi :&amp;quot; --&amp;gt; Avec l&#039;application pas avec la carte mère&lt;br /&gt;
[[Fichier:Envoi.png|néant|vignette|Paquet envoyé par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : &amp;quot; Ajout par la carte&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Elle envoie donc le paquet modifié à l&#039;application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.&lt;br /&gt;
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons donc un fichier qui contient le texte : &amp;quot;Test Envoi : Ajout par la carte&amp;quot;.&lt;br /&gt;
[[Fichier:Recept.png|néant|vignette|Contenu du fichier]]&lt;br /&gt;
&lt;br /&gt;
===== Lecture =====&lt;br /&gt;
Pour lire un fichier sur le PC, nous devons:&lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; de lire un fichier (0x02) --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d&#039;ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l&#039;application&lt;br /&gt;
&lt;br /&gt;
- L&#039;application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --&amp;gt; a envoyer à la carte mère.&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2936</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2936"/>
		<updated>2024-01-17T16:05:11Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Création des différentes taches */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus en simultanée. Parmi les différents processus, il y aura par exemple la lecture et l&#039;écriture sur le port série ou bien un affichage sur une matrice de LED.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
&lt;br /&gt;
==== Création de l&#039;ordonnanceur ====&lt;br /&gt;
Maintenant que le shield que nous souhaitons utilisé est fonctionnel, nous pouvons passer à la partie programmation de la carte en commençant par gérer les interruptions avec notre minuteur.&lt;br /&gt;
&lt;br /&gt;
Il faut que toutes les X ms la fonction d&#039;interruption se lance afin de sauvegarder le contexte de la tache mais aussi pour passer à la tache suivante. Pour cela, nous avons commencer par créer le minuteur puis nous avons créer la fonction d&#039;interruption faisant appel à la fonction ordonnanceur :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction Minuteur&lt;br /&gt;
!ISR&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_timer()&lt;br /&gt;
{&lt;br /&gt;
TCCR1A = 0;  // No output pin connected, no PWM mode enabled&lt;br /&gt;
TCCR1B = 1&amp;lt;&amp;lt;CTC1; // No input pin used, clear timer counter on compare match&lt;br /&gt;
#if (PRESCALER==8)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==64)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==256)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==1024)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
OCR1A = NB_TICK;&lt;br /&gt;
TCNT1 = 0;&lt;br /&gt;
TIMSK1 = (1&amp;lt;&amp;lt;OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED)&lt;br /&gt;
{&lt;br /&gt;
  /* Sauvegarde du contexte de la tâche interrompue */&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[courant].SPointeur = SP;&lt;br /&gt;
  /* Appel à l&#039;ordonnanceur */&lt;br /&gt;
  ordonnanceur();&lt;br /&gt;
&lt;br /&gt;
  /* Récupération du contexte de la tâche ré-activée */&lt;br /&gt;
  SP = ListeTaches[courant].SPointeur;&lt;br /&gt;
  RESTORE_REGISTER();&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;
&lt;br /&gt;
==== Création des différentes taches ====&lt;br /&gt;
Pour créer une taches, nous avons créer une structure comprennant l&#039;action à réaliser ainsi que le Stack Pointer attribuer à cette tache ( par la suite, on gèrera également l&#039;état d&#039;une tache ainsi que la durée de l&#039;état SLEEP ci c&#039;est le cas ) &lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Structure d&#039;une tache&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
struct Tache{&lt;br /&gt;
  void (*fonction)(void);&lt;br /&gt;
  uint16_t SPointeur;&lt;br /&gt;
  int etat;&lt;br /&gt;
  int duree;&lt;br /&gt;
  uint8_t raison;&lt;br /&gt;
};&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
Attention, avant toute chose, il faut penser à initialiser le contexte des taches pour éviter les problèmes liés à la pile. Pour cela, nous avons fait une fonction qui initialise toutes les taches présentent avant le lancement :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Initialisation des taches&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_tache(int N)&lt;br /&gt;
{&lt;br /&gt;
  int saveSP = SP;&lt;br /&gt;
  SP = ListeTaches[N].SPointeur;&lt;br /&gt;
  uint16_t adresse = (uint16_t)ListeTaches[N].fonction;&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; (adresse &amp;amp; 0x00ff));&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; ((adresse &amp;amp; 0xff00) &amp;gt;&amp;gt; 8));&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[N].SPointeur = SP;&lt;br /&gt;
  SP = saveSP;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
On retrouvera l&#039;ensemble des taches dans le fichier [https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK/blob/master/Ordonnanceur/fonction.c fonction.c]&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Création du protocole ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
  uint8_t       Operation;&lt;br /&gt;
  MAC_Address_t MAddr_SRC;&lt;br /&gt;
  IP_Address_t  PAddr_SRC;&lt;br /&gt;
  MAC_Address_t MAddr_DESC;&lt;br /&gt;
  IP_Address_t  PAddr_DESC;&lt;br /&gt;
  uint8_t       Longueur;&lt;br /&gt;
  uint8_t       Data[MAX_DATA];&lt;br /&gt;
} Proto_Header_t;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations.&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
===== Réception =====&lt;br /&gt;
Pour créer un fichier sur le PC, nous devons : &lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; d&#039;envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.&lt;br /&gt;
&lt;br /&gt;
- Le paquet est ensuite renvoyé sur l&#039;application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Exemple :&lt;br /&gt;
&lt;br /&gt;
Nous envoyons donc notre ordre avec en plus un texte : &amp;quot;Test Envoi :&amp;quot; --&amp;gt; Avec l&#039;application pas avec la carte mère&lt;br /&gt;
[[Fichier:Envoi.png|néant|vignette|Paquet envoyé par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : &amp;quot; Ajout par la carte&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Elle envoie donc le paquet modifié à l&#039;application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.&lt;br /&gt;
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons donc un fichier qui contient le texte : &amp;quot;Test Envoi : Ajout par la carte&amp;quot;.&lt;br /&gt;
[[Fichier:Recept.png|néant|vignette|Contenu du fichier]]&lt;br /&gt;
&lt;br /&gt;
===== Lecture =====&lt;br /&gt;
Pour lire un fichier sur le PC, nous devons:&lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; de lire un fichier (0x02) --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d&#039;ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l&#039;application&lt;br /&gt;
&lt;br /&gt;
- L&#039;application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --&amp;gt; a envoyer à la carte mère.&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2935</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2935"/>
		<updated>2024-01-17T15:56:19Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus en simultanée. Parmi les différents processus, il y aura par exemple la lecture et l&#039;écriture sur le port série ou bien un affichage sur une matrice de LED.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
&lt;br /&gt;
==== Création de l&#039;ordonnanceur ====&lt;br /&gt;
Maintenant que le shield que nous souhaitons utilisé est fonctionnel, nous pouvons passer à la partie programmation de la carte en commençant par gérer les interruptions avec notre minuteur.&lt;br /&gt;
&lt;br /&gt;
Il faut que toutes les X ms la fonction d&#039;interruption se lance afin de sauvegarder le contexte de la tache mais aussi pour passer à la tache suivante. Pour cela, nous avons commencer par créer le minuteur puis nous avons créer la fonction d&#039;interruption faisant appel à la fonction ordonnanceur :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction Minuteur&lt;br /&gt;
!ISR&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_timer()&lt;br /&gt;
{&lt;br /&gt;
TCCR1A = 0;  // No output pin connected, no PWM mode enabled&lt;br /&gt;
TCCR1B = 1&amp;lt;&amp;lt;CTC1; // No input pin used, clear timer counter on compare match&lt;br /&gt;
#if (PRESCALER==8)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==64)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==256)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==1024)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
OCR1A = NB_TICK;&lt;br /&gt;
TCNT1 = 0;&lt;br /&gt;
TIMSK1 = (1&amp;lt;&amp;lt;OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED)&lt;br /&gt;
{&lt;br /&gt;
  /* Sauvegarde du contexte de la tâche interrompue */&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[courant].SPointeur = SP;&lt;br /&gt;
  /* Appel à l&#039;ordonnanceur */&lt;br /&gt;
  ordonnanceur();&lt;br /&gt;
&lt;br /&gt;
  /* Récupération du contexte de la tâche ré-activée */&lt;br /&gt;
  SP = ListeTaches[courant].SPointeur;&lt;br /&gt;
  RESTORE_REGISTER();&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;
&lt;br /&gt;
==== Création des différentes taches ====&lt;br /&gt;
Attention, avant toute chose, il faut penser à initialiser le contexte des taches pour éviter les problèmes liés à la pile. Pour cela, nous avons fait une fonction qui initialise toutes les taches présentent avant le lancement :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Initialisation des taches&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_tache(int N)&lt;br /&gt;
{&lt;br /&gt;
  int saveSP = SP;&lt;br /&gt;
  SP = ListeTaches[N].SPointeur;&lt;br /&gt;
  uint16_t adresse = (uint16_t)ListeTaches[N].fonction;&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; (adresse &amp;amp; 0x00ff));&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; ((adresse &amp;amp; 0xff00) &amp;gt;&amp;gt; 8));&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[N].SPointeur = SP;&lt;br /&gt;
  SP = saveSP;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Création du protocole ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
  uint8_t       Operation;&lt;br /&gt;
  MAC_Address_t MAddr_SRC;&lt;br /&gt;
  IP_Address_t  PAddr_SRC;&lt;br /&gt;
  MAC_Address_t MAddr_DESC;&lt;br /&gt;
  IP_Address_t  PAddr_DESC;&lt;br /&gt;
  uint8_t       Longueur;&lt;br /&gt;
  uint8_t       Data[MAX_DATA];&lt;br /&gt;
} Proto_Header_t;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations.&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
===== Réception =====&lt;br /&gt;
Pour créer un fichier sur le PC, nous devons : &lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; d&#039;envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.&lt;br /&gt;
&lt;br /&gt;
- Le paquet est ensuite renvoyé sur l&#039;application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Exemple :&lt;br /&gt;
&lt;br /&gt;
Nous envoyons donc notre ordre avec en plus un texte : &amp;quot;Test Envoi :&amp;quot; --&amp;gt; Avec l&#039;application pas avec la carte mère&lt;br /&gt;
[[Fichier:Envoi.png|néant|vignette|Paquet envoyé par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : &amp;quot; Ajout par la carte&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Elle envoie donc le paquet modifié à l&#039;application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.&lt;br /&gt;
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons donc un fichier qui contient le texte : &amp;quot;Test Envoi : Ajout par la carte&amp;quot;.&lt;br /&gt;
[[Fichier:Recept.png|néant|vignette|Contenu du fichier]]&lt;br /&gt;
&lt;br /&gt;
===== Lecture =====&lt;br /&gt;
Pour lire un fichier sur le PC, nous devons:&lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; de lire un fichier (0x02) --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d&#039;ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l&#039;application&lt;br /&gt;
&lt;br /&gt;
- L&#039;application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --&amp;gt; a envoyer à la carte mère.&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2934</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2934"/>
		<updated>2024-01-17T15:54:28Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus en simultanée. Parmi les différents processus, il y aura par exemple la lecture et l&#039;écriture sur le port série ou bien un affichage sur une matrice de LED.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Maintenant que le shield que nous souhaitons utilisé est fonctionnel, nous pouvons passer à la partie programmation de la carte en commençant par gérer les interruptions avec notre minuteur.&lt;br /&gt;
&lt;br /&gt;
Il faut que toutes les X ms la fonction d&#039;interruption se lance afin de sauvegarder le contexte de la tache mais aussi pour passer à la tache suivante. Pour cela, nous avons commencer par créer le minuteur puis nous avons créer la fonction d&#039;interruption faisant appel à la fonction ordonnanceur :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction Minuteur&lt;br /&gt;
!ISR&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_timer()&lt;br /&gt;
{&lt;br /&gt;
TCCR1A = 0;  // No output pin connected, no PWM mode enabled&lt;br /&gt;
TCCR1B = 1&amp;lt;&amp;lt;CTC1; // No input pin used, clear timer counter on compare match&lt;br /&gt;
#if (PRESCALER==8)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==64)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==256)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==1024)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
OCR1A = NB_TICK;&lt;br /&gt;
TCNT1 = 0;&lt;br /&gt;
TIMSK1 = (1&amp;lt;&amp;lt;OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
ISR(TIMER1_COMPA_vect,ISR_NAKED)&lt;br /&gt;
{&lt;br /&gt;
  /* Sauvegarde du contexte de la tâche interrompue */&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[courant].SPointeur = SP;&lt;br /&gt;
  /* Appel à l&#039;ordonnanceur */&lt;br /&gt;
  ordonnanceur();&lt;br /&gt;
&lt;br /&gt;
  /* Récupération du contexte de la tâche ré-activée */&lt;br /&gt;
  SP = ListeTaches[courant].SPointeur;&lt;br /&gt;
  RESTORE_REGISTER();&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;
Attention, il faut penser à initialiser le contexte des taches pour éviter les problèmes liés à la pile. Pour cela, nous avons fait une fonction qui initialise toutes les taches présentent avant le lancement :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Initialisation des taches&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_tache(int N)&lt;br /&gt;
{&lt;br /&gt;
  int saveSP = SP;&lt;br /&gt;
  SP = ListeTaches[N].SPointeur;&lt;br /&gt;
  uint16_t adresse = (uint16_t)ListeTaches[N].fonction;&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; (adresse &amp;amp; 0x00ff));&lt;br /&gt;
  asm volatile (&amp;quot;push %0 \n\t&amp;quot; : : &amp;quot;r&amp;quot; ((adresse &amp;amp; 0xff00) &amp;gt;&amp;gt; 8));&lt;br /&gt;
  SAVE_REGISTER();&lt;br /&gt;
  ListeTaches[N].SPointeur = SP;&lt;br /&gt;
  SP = saveSP;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Création du protocole ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
  uint8_t       Operation;&lt;br /&gt;
  MAC_Address_t MAddr_SRC;&lt;br /&gt;
  IP_Address_t  PAddr_SRC;&lt;br /&gt;
  MAC_Address_t MAddr_DESC;&lt;br /&gt;
  IP_Address_t  PAddr_DESC;&lt;br /&gt;
  uint8_t       Longueur;&lt;br /&gt;
  uint8_t       Data[MAX_DATA];&lt;br /&gt;
} Proto_Header_t;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations.&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
===== Réception =====&lt;br /&gt;
Pour créer un fichier sur le PC, nous devons : &lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; d&#039;envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.&lt;br /&gt;
&lt;br /&gt;
- Le paquet est ensuite renvoyé sur l&#039;application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Exemple :&lt;br /&gt;
&lt;br /&gt;
Nous envoyons donc notre ordre avec en plus un texte : &amp;quot;Test Envoi :&amp;quot; --&amp;gt; Avec l&#039;application pas avec la carte mère&lt;br /&gt;
[[Fichier:Envoi.png|néant|vignette|Paquet envoyé par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : &amp;quot; Ajout par la carte&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Elle envoie donc le paquet modifié à l&#039;application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.&lt;br /&gt;
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons donc un fichier qui contient le texte : &amp;quot;Test Envoi : Ajout par la carte&amp;quot;.&lt;br /&gt;
[[Fichier:Recept.png|néant|vignette|Contenu du fichier]]&lt;br /&gt;
&lt;br /&gt;
===== Lecture =====&lt;br /&gt;
Pour lire un fichier sur le PC, nous devons:&lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; de lire un fichier (0x02) --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d&#039;ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l&#039;application&lt;br /&gt;
&lt;br /&gt;
- L&#039;application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --&amp;gt; a envoyer à la carte mère.&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2930</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2930"/>
		<updated>2024-01-17T15:48:57Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus en simultanée. Parmi les différents processus, il y aura par exemple la lecture et l&#039;écriture sur le port série ou bien un affichage sur une matrice de LED.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Maintenant que le shield que nous souhaitons utilisé est fonctionnel, nous pouvons passer à la partie programmation de la carte en commençant par gérer les interruptions avec notre minuteur :&lt;br /&gt;
&lt;br /&gt;
Il faut que toutes les X ms la fonction d&#039;interruption se lance afin de sauvegarder le contexte de la tache mais aussi pour passer à la tache suivante. Pour cela, nous avons commencer par créer le minuteur puis nous avons créer la fonction d&#039;interruption faisant appel à la fonction ordonnanceur :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction Minuteur&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_timer()&lt;br /&gt;
{&lt;br /&gt;
TCCR1A = 0;  // No output pin connected, no PWM mode enabled&lt;br /&gt;
TCCR1B = 1&amp;lt;&amp;lt;CTC1; // No input pin used, clear timer counter on compare match&lt;br /&gt;
#if (PRESCALER==8)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==64)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==256)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==1024)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
OCR1A = NB_TICK;&lt;br /&gt;
TCNT1 = 0;&lt;br /&gt;
TIMSK1 = (1&amp;lt;&amp;lt;OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Création du protocole ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
  uint8_t       Operation;&lt;br /&gt;
  MAC_Address_t MAddr_SRC;&lt;br /&gt;
  IP_Address_t  PAddr_SRC;&lt;br /&gt;
  MAC_Address_t MAddr_DESC;&lt;br /&gt;
  IP_Address_t  PAddr_DESC;&lt;br /&gt;
  uint8_t       Longueur;&lt;br /&gt;
  uint8_t       Data[MAX_DATA];&lt;br /&gt;
} Proto_Header_t;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations.&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
===== Réception =====&lt;br /&gt;
Pour créer un fichier sur le PC, nous devons : &lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; d&#039;envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.&lt;br /&gt;
&lt;br /&gt;
- Le paquet est ensuite renvoyé sur l&#039;application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Exemple :&lt;br /&gt;
&lt;br /&gt;
Nous envoyons donc notre ordre avec en plus un texte : &amp;quot;Test Envoi :&amp;quot; --&amp;gt; Avec l&#039;application pas avec la carte mère&lt;br /&gt;
[[Fichier:Envoi.png|néant|vignette|Paquet envoyé par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : &amp;quot; Ajout par la carte&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Elle envoie donc le paquet modifié à l&#039;application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.&lt;br /&gt;
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons donc un fichier qui contient le texte : &amp;quot;Test Envoi : Ajout par la carte&amp;quot;.&lt;br /&gt;
[[Fichier:Recept.png|néant|vignette|Contenu du fichier]]&lt;br /&gt;
&lt;br /&gt;
===== Lecture =====&lt;br /&gt;
Pour lire un fichier sur le PC, nous devons:&lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; de lire un fichier (0x02) --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d&#039;ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l&#039;application&lt;br /&gt;
&lt;br /&gt;
- L&#039;application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --&amp;gt; a envoyer à la carte mère.&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2928</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2928"/>
		<updated>2024-01-17T15:46:14Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Ordonnanceur */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus en simultanée. Parmi les différents processus, il y aura par exemple la lecture et l&#039;écriture sur le port série ou bien un affichage sur une matrice de LED.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Maintenant que le shield que nous souhaitons utilisé est fonctionnel, nous pouvons passer à la partie programmation de la carte en commençant par gerer les interruptions avec notre minuteur :&lt;br /&gt;
&lt;br /&gt;
Il faut que toutes les X ms la fonction d&#039;interruption se lance afin de sauvegarder le contexte de la tache, pour cela nous avons commencer par creer le minuteur :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Fonction Minuteur&lt;br /&gt;
|-&lt;br /&gt;
|&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void init_timer()&lt;br /&gt;
{&lt;br /&gt;
TCCR1A = 0;  // No output pin connected, no PWM mode enabled&lt;br /&gt;
TCCR1B = 1&amp;lt;&amp;lt;CTC1; // No input pin used, clear timer counter on compare match&lt;br /&gt;
#if (PRESCALER==8)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==64)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS11 | 11&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==256)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12);&lt;br /&gt;
#endif&lt;br /&gt;
#if (PRESCALER==1024)&lt;br /&gt;
 TCCR1B |= (1&amp;lt;&amp;lt;CS12 | 1&amp;lt;&amp;lt;CS10);&lt;br /&gt;
#endif&lt;br /&gt;
OCR1A = NB_TICK;&lt;br /&gt;
TCNT1 = 0;&lt;br /&gt;
TIMSK1 = (1&amp;lt;&amp;lt;OCIE1A); // No overflow mode enabled, no input interrupt, output compare interrupt&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Création du protocole ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
  uint8_t       Operation;&lt;br /&gt;
  MAC_Address_t MAddr_SRC;&lt;br /&gt;
  IP_Address_t  PAddr_SRC;&lt;br /&gt;
  MAC_Address_t MAddr_DESC;&lt;br /&gt;
  IP_Address_t  PAddr_DESC;&lt;br /&gt;
  uint8_t       Longueur;&lt;br /&gt;
  uint8_t       Data[MAX_DATA];&lt;br /&gt;
} Proto_Header_t;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations.&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
===== Réception =====&lt;br /&gt;
Pour créer un fichier sur le PC, nous devons : &lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; d&#039;envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.&lt;br /&gt;
&lt;br /&gt;
- Le paquet est ensuite renvoyé sur l&#039;application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Exemple :&lt;br /&gt;
&lt;br /&gt;
Nous envoyons donc notre ordre avec en plus un texte : &amp;quot;Test Envoi :&amp;quot; --&amp;gt; Avec l&#039;application pas avec la carte mère&lt;br /&gt;
[[Fichier:Envoi.png|néant|vignette|Paquet envoyé par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : &amp;quot; Ajout par la carte&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Elle envoie donc le paquet modifié à l&#039;application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.&lt;br /&gt;
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons donc un fichier qui contient le texte : &amp;quot;Test Envoi : Ajout par la carte&amp;quot;.&lt;br /&gt;
[[Fichier:Recept.png|néant|vignette|Contenu du fichier]]&lt;br /&gt;
&lt;br /&gt;
===== Lecture =====&lt;br /&gt;
Pour lire un fichier sur le PC, nous devons:&lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; de lire un fichier (0x02) --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d&#039;ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l&#039;application&lt;br /&gt;
&lt;br /&gt;
- L&#039;application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --&amp;gt; a envoyer à la carte mère.&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2585</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2585"/>
		<updated>2023-12-21T11:21:28Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Création du protocole ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
  uint8_t       Operation;&lt;br /&gt;
  MAC_Address_t MAddr_SRC;&lt;br /&gt;
  IP_Address_t  PAddr_SRC;&lt;br /&gt;
  MAC_Address_t MAddr_DESC;&lt;br /&gt;
  IP_Address_t  PAddr_DESC;&lt;br /&gt;
  uint8_t       Longueur;&lt;br /&gt;
  uint8_t       Data[MAX_DATA];&lt;br /&gt;
} Proto_Header_t;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations.&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
===== Réception =====&lt;br /&gt;
Pour créer un fichier sur le PC, nous devons : &lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; d&#039;envoyer un fichier (0x03), ce paquet peut aussi contenir une partie de texte à écrire --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite ce paquet en ayant la possibilité de rajouter une autre partie de texte à écrire dans le fichier.&lt;br /&gt;
&lt;br /&gt;
- Le paquet est ensuite renvoyé sur l&#039;application et celle-ci ouvre le fichier et écrit dedans à partir des informations du paquet.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Exemple :&lt;br /&gt;
&lt;br /&gt;
Nous envoyons donc notre ordre avec en plus un texte : &amp;quot;Test Envoi :&amp;quot; --&amp;gt; Avec l&#039;application pas avec la carte mère&lt;br /&gt;
[[Fichier:Envoi.png|néant|vignette|Paquet envoyé par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
La carte reçoit ce paquet, le modifie en échangeant notamment les adresses de destinations et de sources, et ajoute une partie de texte : &amp;quot; Ajout par la carte&amp;quot;&lt;br /&gt;
&lt;br /&gt;
Elle envoie donc le paquet modifié à l&#039;application PC qui crée le fichier (Reception.txt) et écrit dedans à partir de la DATA du paquet.&lt;br /&gt;
[[Fichier:Recu.png|néant|vignette|Paquet reçu par l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons donc un fichier qui contient le texte : &amp;quot;Test Envoi : Ajout par la carte&amp;quot;.&lt;br /&gt;
[[Fichier:Recept.png|néant|vignette|Contenu du fichier]]&lt;br /&gt;
&lt;br /&gt;
===== Lecture =====&lt;br /&gt;
Pour lire un fichier sur le PC, nous devons:&lt;br /&gt;
&lt;br /&gt;
- Envoyer avec l&#039;application, un paquet contenant &amp;quot;l&#039;ordre&amp;quot; de lire un fichier (0x02) --&amp;gt; Il aurait fallu que cette opération s&#039;effectue grâce au bus SPI et à la carte mère.&lt;br /&gt;
&lt;br /&gt;
- Une fois le paquet reçu, la carte traite le paquet en ayant la possibilité d&#039;ajouter des caractères pour confirmer la lecture. Elle renvoie ensuite le paquet à l&#039;application&lt;br /&gt;
&lt;br /&gt;
- L&#039;application lit dans le fichier (Lecture.txt) en ayant le texte ajouter par la carte et affiche le paquet modifié --&amp;gt; a envoyer à la carte mère.&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Recept.png&amp;diff=2580</id>
		<title>Fichier:Recept.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Recept.png&amp;diff=2580"/>
		<updated>2023-12-21T10:59:07Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Recept&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Recu.png&amp;diff=2579</id>
		<title>Fichier:Recu.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Recu.png&amp;diff=2579"/>
		<updated>2023-12-21T10:57:52Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;recu&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Envoi.png&amp;diff=2578</id>
		<title>Fichier:Envoi.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Envoi.png&amp;diff=2578"/>
		<updated>2023-12-21T10:57:18Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Envoi&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2554</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2554"/>
		<updated>2023-12-21T07:57:29Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Test LUFA RNDIS */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
Voici la structure de notre protocole :&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
blabla&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destinations.&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresses lorsqu&#039;on utilise notre protocole.&lt;br /&gt;
&lt;br /&gt;
* Finalement, nous souhaitons créer un fichier sur le PC lorsque la carte reçoit une opération 0x03&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2553</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2553"/>
		<updated>2023-12-21T07:55:30Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Test LUFA RNDIS */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]Nous avons donc bien un écho avec inversion des adresse lorsqu&#039;on utilise notre protocole&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2552</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2552"/>
		<updated>2023-12-21T07:54:43Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Test LUFA RNDIS */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;br /&gt;
[[Fichier:Image des paquets.jpg|néant|vignette|Image des paquets]]&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Image_des_paquets.jpg&amp;diff=2551</id>
		<title>Fichier:Image des paquets.jpg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Image_des_paquets.jpg&amp;diff=2551"/>
		<updated>2023-12-21T07:54:33Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Image des paquets&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2550</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2550"/>
		<updated>2023-12-21T07:53:42Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;br /&gt;
[[Fichier:Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet.mp4|néant|vignette|Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet]]&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Renvoie_d%27un_%22%C3%A9cho%22_du_paquet.mp4&amp;diff=2549</id>
		<title>Fichier:Renvoie d&#039;un &quot;écho&quot; du paquet.mp4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Renvoie_d%27un_%22%C3%A9cho%22_du_paquet.mp4&amp;diff=2549"/>
		<updated>2023-12-21T07:53:31Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Renvoie d&#039;un &amp;quot;écho&amp;quot; du paquet&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2548</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2548"/>
		<updated>2023-12-21T07:34:00Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2547</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2547"/>
		<updated>2023-12-21T07:33:41Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
\n&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2546</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2546"/>
		<updated>2023-12-21T07:33:20Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2545</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2545"/>
		<updated>2023-12-21T07:32:08Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Carte FPGA */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2544</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2544"/>
		<updated>2023-12-21T07:31:09Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2543</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2543"/>
		<updated>2023-12-21T07:30:58Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK &amp;lt;br&amp;gt;&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2542</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2542"/>
		<updated>2023-12-21T07:28:22Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment :&lt;br /&gt;
[[Fichier:Demonstration USART.mp4|néant|vignette|Demo USART]]&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Demonstration_USART.mp4&amp;diff=2541</id>
		<title>Fichier:Demonstration USART.mp4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Demonstration_USART.mp4&amp;diff=2541"/>
		<updated>2023-12-21T07:28:01Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;demo USART&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2538</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2538"/>
		<updated>2023-12-21T07:24:25Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
La vidéo ci-dessous montre une lecture sur clavier puis une écriture sur minicom du caractère lu précédemment.&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2537</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2537"/>
		<updated>2023-12-21T07:19:04Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0x1111.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole est reconnu par notre carte lors d&#039;un envoi de paquet.&lt;br /&gt;
&lt;br /&gt;
* La troisième étape consiste à renvoyer un paquet lorsque la carte en reçoit un --&amp;gt; OK (voir vidéo ci-dessous)&lt;br /&gt;
&lt;br /&gt;
Il faut que, avant d&#039;envoyer le paquet, la carte modifie ce paquet notamment en inversant les adresses sources et destination&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2536</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2536"/>
		<updated>2023-12-21T07:10:21Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Test LUFA RNDIS */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0xff15.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole par notre carte lors d&#039;un envoi de paquet.&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2471</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2471"/>
		<updated>2023-12-12T14:45:48Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;br /&gt;
&lt;br /&gt;
* La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0xff15.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
	switch (SwapEndian_16(FrameINHeader-&amp;gt;EtherType))&lt;br /&gt;
	  {&lt;br /&gt;
	  case ETHERTYPE_ARP:&lt;br /&gt;
	    RetSize = ARP_ProcessARPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_IPV4:&lt;br /&gt;
	    RetSize = IP_ProcessIPPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
					   &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  case ETHERTYPE_MONPROTO:	  &lt;br /&gt;
	    RetSize = MonProto_ProcessPacket(&amp;amp;FrameIN.FrameData[sizeof(Ethernet_Frame_Header_t)],&lt;br /&gt;
				       &amp;amp;FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)]);&lt;br /&gt;
	    break;&lt;br /&gt;
	  }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole par notre carte lors d&#039;un envoi de paquet&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2470</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2470"/>
		<updated>2023-12-12T14:41:33Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]La seconde étape consiste à modifier les fichiers de la LUFA pour créer notre propre protocole. On a choisi pour ce protocole 0xff15.&lt;br /&gt;
&lt;br /&gt;
Une fois créé et ajouté dans le choix des protocoles dans le code du traitement des paquets Ethernet, le protocole par notre carte lors d&#039;un envoi de paquet&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2463</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2463"/>
		<updated>2023-12-11T15:21:01Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB avec utilisation des sémaphores : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2462</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2462"/>
		<updated>2023-12-11T15:20:08Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo)&lt;br /&gt;
[[Fichier:LecturePaquets.mp4|néant|vignette|Lecture des paquets sur l&#039;application]]&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:LecturePaquets.mp4&amp;diff=2461</id>
		<title>Fichier:LecturePaquets.mp4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:LecturePaquets.mp4&amp;diff=2461"/>
		<updated>2023-12-11T15:18:36Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;LecturePaquets&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2459</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2459"/>
		<updated>2023-12-11T15:16:23Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]Il faut ensuite utiliser une application développer sur le PC  pour recevoir ou envoyer des paquets Ethernet sur notre carte :&lt;br /&gt;
&lt;br /&gt;
* Comme premier test, nous avons fait le choix de lire les paquets sur notre interface lors d&#039;un ping sur celle ci --&amp;gt; OK (voir vidéo)&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2457</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2457"/>
		<updated>2023-12-11T15:08:54Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2456</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2456"/>
		<updated>2023-12-11T15:08:40Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED.mp4|néant|vignette|PingLED]]&lt;br /&gt;
&lt;br /&gt;
[[Fichier:PingLED PingLED.mp4|vignette|0x0px|PingLED]]&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2455</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2455"/>
		<updated>2023-12-11T15:07:11Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;br /&gt;
[[Fichier:PingLED PingLED.mp4|vignette|0x0px|PingLED]]&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:PingLED.mp4&amp;diff=2454</id>
		<title>Fichier:PingLED.mp4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:PingLED.mp4&amp;diff=2454"/>
		<updated>2023-12-11T15:04:01Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;PingLED&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2453</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2453"/>
		<updated>2023-12-11T14:58:43Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Paquet */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous allons d&#039;abord tester que notre carte traite les requêtes de ping : pour cela, il faut changer l&#039;état de la LED lorsqu’une requête est reçue. (Voir vidéo ci-dessous)&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2452</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2452"/>
		<updated>2023-12-11T14:55:02Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Test LUFA RNDIS */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]] &lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.100/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;Et &amp;quot;allumer&amp;quot; l&#039;interface usb0 :&amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip link set usb0 up&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:IPA.png|néant|vignette|Vérification ip a]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping le réseau de notre carte RNDIS  (10.0.0.2) :&lt;br /&gt;
[[Fichier:PING ping.png|néant|vignette|ping 10.0.0.2]]&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
(en cours)&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:PING_ping.png&amp;diff=2451</id>
		<title>Fichier:PING ping.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:PING_ping.png&amp;diff=2451"/>
		<updated>2023-12-11T14:54:31Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;ping&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:IPA.png&amp;diff=2450</id>
		<title>Fichier:IPA.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:IPA.png&amp;diff=2450"/>
		<updated>2023-12-11T14:51:38Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;IPA&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2439</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2439"/>
		<updated>2023-12-11T13:33:04Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Test Basique */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]]&lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.2/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:Ipa RNDIS.png|néant|vignette|Test ip a]]&lt;br /&gt;
Nous pouvons, suite à cela, ping notre carte RNDIS :&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
(en cours)&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2383</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2383"/>
		<updated>2023-12-11T09:28:58Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Test LUFA RNDIS */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]]&lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.2/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:Ipa RNDIS.png|néant|vignette|Test ip a]]&lt;br /&gt;
Nous pouvons, suite à cela, ping notre carte RNDIS :[[Fichier:PING RNDIS.png|néant|vignette|Ping]]&lt;br /&gt;
&lt;br /&gt;
==== Paquet ====&lt;br /&gt;
(en cours)&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2381</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2381"/>
		<updated>2023-12-11T09:27:54Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Test LUFA RNDIS */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]]&lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.2/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:Ipa RNDIS.png|néant|vignette|Test ip a]]&lt;br /&gt;
Nous pouvons, suite à cela, ping notre carte RNDIS :[[Fichier:PING RNDIS.png|néant|vignette|Ping]]&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2379</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2379"/>
		<updated>2023-12-11T09:27:26Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Partie 2 : Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
==== Test Basique ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Test LUFA RNDIS ====&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]]&lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.2/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:Ipa RNDIS.png|néant|vignette|Test ip a]]&lt;br /&gt;
Nous pouvons, suite à cela, ping notre carte RNDIS :&lt;br /&gt;
&lt;br /&gt;
Nous pouvons, suite à cela, ping notre carte RNDIS :&lt;br /&gt;
[[Fichier:PING RNDIS.png|néant|vignette|Ping]]&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2376</id>
		<title>SE4Binome2023-4</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2023-4&amp;diff=2376"/>
		<updated>2023-12-11T09:26:02Z</updated>

		<summary type="html">&lt;p&gt;Tnave : /* Partie 2 : Programmation */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== GIT ==&lt;br /&gt;
&lt;br /&gt;
Adresse du GIT : https://archives.plil.fr/tnave/PICO_Thomas_NAVE_Thibault_DUYCK.git&lt;br /&gt;
== Ordonnanceur ==&lt;br /&gt;
&lt;br /&gt;
Pour la réalisation de notre pico-ordinateur, nous devons réaliser un ordonnanceur qui permettra de gérer nos différents processus.&lt;br /&gt;
&lt;br /&gt;
=== Réalisation du shield ===&lt;br /&gt;
La première étape consiste à réaliser le shield et le connecteur pour la matrice de LED qui nous permettra d&#039;effectuer tous les tests liés au programme de l&#039;ordonnanceur.&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
![[Fichier:Shield partie 1.jpg|vignette|191x191px|Première partie du shield|centré]]&lt;br /&gt;
![[Fichier:Shield final.jpg|vignette|252x252px|Shield terminé|centré]]&lt;br /&gt;
|-&lt;br /&gt;
![[Fichier:Adaptateur pour la matrice led.jpg|vignette|252x252px|Adaptateur LED|centré]]&lt;br /&gt;
![[Fichier:Cable.jpg|vignette|252x252px|Câbles|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons testé les LED de notre ordonnanceur avec un code basique pour vérifier si les soudures étaient bonnes et si on arrivait à utiliser les Chip Select de la carte :&lt;br /&gt;
[[Fichier:Presentation led.jpg|vignette|LED Shield|300x300px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led(){&lt;br /&gt;
  DDRD=0x92;&lt;br /&gt;
  DDRC=0x09;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
	PORTD=0x92;&lt;br /&gt;
	PORTC=0x09;&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programmation ===&lt;br /&gt;
Nous pouvons donc commencer à travailler sur l’ordonnanceur :&lt;br /&gt;
&lt;br /&gt;
* Première étape : Création d&#039;un ordonnanceur avec test sur 2 LED (avec delay_ms) : OK&lt;br /&gt;
* Deuxième étape : Modification du code afin d&#039;avoir un état &amp;quot;ACTIF&amp;quot; ou &amp;quot;SLEEP&amp;quot; sur une tâche : OK&lt;br /&gt;
* Troisième étape : Ajout de la lecture et de l&#039;écriture sur le port USB : OK&lt;br /&gt;
&lt;br /&gt;
* Quatrième étape : Gestion de la matrice de LED avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
&lt;br /&gt;
[[Fichier:MatriceLED.mp4|vignette|Matrice de LED|néant]]&lt;br /&gt;
&lt;br /&gt;
* Cinquième étape : Gestion du 7-segments avec la lecture sur port USB : OK ( voir vidéo )&lt;br /&gt;
[[Fichier:7seg.mp4|vignette|7-segments|néant]]&lt;br /&gt;
&lt;br /&gt;
Nous avons complété l&#039;ordonnanceur avec ses différentes tâches. Cependant, pour que les deux tâches utilisant le bus SPI fonctionnent en simultané, il faudrait ajouter une tache supplémentaire contrôlant ce bus SPI.&lt;br /&gt;
== Carte FPGA ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
.......&lt;br /&gt;
&lt;br /&gt;
== Carte électronique numérique ==&lt;br /&gt;
&lt;br /&gt;
=== Carte choisie : Carte Réseau RNDIS ===&lt;br /&gt;
Commentaire :  &lt;br /&gt;
&lt;br /&gt;
- Problème 1 : Mauvais positionnement de Chip Select dans la conception --&amp;gt; OK &lt;br /&gt;
&lt;br /&gt;
=== Partie 1 : Réalisation de la carte ===&lt;br /&gt;
Il faut donc effectuer la conception de la carte :&lt;br /&gt;
&lt;br /&gt;
On commence par le schematic ci-joint&lt;br /&gt;
[[Fichier:SchemRNDIS.png|centré|vignette|730x730px|Schematic carte RNDIS]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Après avoir terminé le schematic, on peut passer au routage de la carte&lt;br /&gt;
[[Fichier:Routagepico.png|centré|vignette|424x424px|Routage]]Une fois la carte recue, il faut passer à la soudure :&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; style=&amp;quot;margin: auto; width: 50%;&amp;quot;&lt;br /&gt;
|+&lt;br /&gt;
!Carte Vide[[Fichier:CarteVide.jpg|vignette|Carte Vide|centré]]&lt;br /&gt;
!Carte Soudée[[Fichier:CarteSoudé.jpg|vignette|Carte Soudée|centré]]&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons constaté par la suite que le Chip Select du SPI devait se trouver sur le PB0 ainsi nous avons ajouter un fil d&#039;étain entre PB0 et PB4 pour régler ce problème&lt;br /&gt;
&lt;br /&gt;
=== Partie 2 : Programmation ===&lt;br /&gt;
Maintenant que la carte est utilisable, il nous faut passer à la programmation de celle-ci&lt;br /&gt;
&lt;br /&gt;
Nous avons commencer par un code simple allumant la LED de notre carte pour vérifier que l&#039;envoie du code s&#039;effectue correctement sur la carte et que les soudures sont bonnes.[[Fichier:VideoRNDIS LED.mp4|vignette|0x0px|LED RNDIS]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;avr/io.h&amp;gt;&lt;br /&gt;
#include &amp;lt;util/delay.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void init_led()&lt;br /&gt;
{&lt;br /&gt;
  DDRD=0x01;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(){&lt;br /&gt;
  CLKSEL0 = 0b00010101;   // sélection de l&#039;horloge externe&lt;br /&gt;
  CLKSEL1 = 0b00001111;   // minimum de 8Mhz&lt;br /&gt;
  CLKPR = 0b10000000;     // modification du diviseur d&#039;horloge (CLKPCE=1)&lt;br /&gt;
  CLKPR = 0;              // 0 pour pas de diviseur (diviseur de 1)&lt;br /&gt;
  init_led();&lt;br /&gt;
  while(1)&lt;br /&gt;
    {&lt;br /&gt;
      PORTD=0x01;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
      PORTD=0x00;&lt;br /&gt;
      _delay_ms(500);&lt;br /&gt;
    }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nous avons utilisé la démonstration LUFA RNDIS pour que notre carte soit reconnu comme carte RNDIS&lt;br /&gt;
&lt;br /&gt;
Pour cela, il a fallu réduire la taille de la pile pour adapter la démonstration à notre Atmega16u2. Nous avons fait le choix de réduire la pile en laissant l&#039;Ethernet et ICMP.&lt;br /&gt;
&lt;br /&gt;
Une fois cela effectué, nous pouvons constater que notre carte est bien reconnue comme carte RNDIS et elle possède sa propre interface &amp;quot;usb0&amp;quot;&lt;br /&gt;
[[Fichier:Lsusb RNDIS.png|néant|vignette|Test lsusb]]&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Par la suite, il faut affecter une adresse IP à notre carte : &amp;lt;syntaxhighlight lang=&amp;quot;shell&amp;quot;&amp;gt;&lt;br /&gt;
ip address add 10.0.0.2/24 dev usb0&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;On obtient avec ip a :&lt;br /&gt;
[[Fichier:Ipa RNDIS.png|néant|vignette|Test ip a]]&lt;br /&gt;
Nous pouvons, suite à cela, ping notre carte RNDIS :&lt;br /&gt;
[[Fichier:PING RNDIS.png|néant|vignette|Ping]]&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:PING_RNDIS.png&amp;diff=2375</id>
		<title>Fichier:PING RNDIS.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:PING_RNDIS.png&amp;diff=2375"/>
		<updated>2023-12-11T09:25:49Z</updated>

		<summary type="html">&lt;p&gt;Tnave : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;RNDIS&lt;/div&gt;</summary>
		<author><name>Tnave</name></author>
	</entry>
</feed>