<?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=Jramesh</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=Jramesh"/>
	<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php/Sp%C3%A9cial:Contributions/Jramesh"/>
	<updated>2026-11-18T17:16:53Z</updated>
	<subtitle>Contributions</subtitle>
	<generator>MediaWiki 1.39.1</generator>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11260</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11260"/>
		<updated>2026-09-10T15:16:29Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Hardware  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
Choix importants: &amp;lt;br&amp;gt;&lt;br /&gt;
_ alimentation de l&#039;ATmega32U4 en 3.3V plutôt qu&#039;en 5V  &amp;lt;br&amp;gt;&lt;br /&gt;
_ Convention pour remplacer le connecteur HE10 :  &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
_ Flash : AT45DB641E (min 1.7V - max 3.6V)&lt;br /&gt;
_&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11258</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11258"/>
		<updated>2026-09-10T15:03:13Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Hardware  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
Choix : &amp;lt;br&amp;gt;&lt;br /&gt;
_ alimentation de l&#039;ATmega32U4 en 3.3V plutôt qu&#039;en 5V  &amp;lt;br&amp;gt;&lt;br /&gt;
_ Flash : AT45DB641E (min 1.7V - max 3.6V)&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11257</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11257"/>
		<updated>2026-09-10T14:42:30Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Hardware  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
Choix : &amp;lt;br&amp;gt;&lt;br /&gt;
_ alimentation de l&#039;ATmega32U4 en 3.3V plutôt qu&#039;en 5V  &amp;lt;br&amp;gt;&lt;br /&gt;
_ Memory chip AT45DB641E (min 1.7V - max 3.6V)&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11256</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11256"/>
		<updated>2026-09-10T14:40:11Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Hardware  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
Choix : &amp;lt;br&amp;gt;&lt;br /&gt;
_ alimentation de l&#039;ATmega32U4 en 3.3V plutôt qu&#039;en 5V  &amp;lt;br&amp;gt;&lt;br /&gt;
_ Memory chip AT45DB641E (max 3.6V)&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11251</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11251"/>
		<updated>2026-09-10T14:30:54Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Hardware  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
Choix libres: &amp;lt;br&amp;gt;&lt;br /&gt;
_ alimentation de l&#039;ATmega32U4 en 3.3V plutôt qu&#039;en 5V  &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11249</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11249"/>
		<updated>2026-09-10T14:22:01Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Hardware  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
Choix libres: &amp;lt;br&amp;gt;&lt;br /&gt;
_ alimentation de l&#039;ATmega32U4 en 3.3V plutôt qu&#039;en 5V  &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Cahier de charges :   &amp;lt;br&amp;gt;&lt;br /&gt;
_ Crystal de 8MHZ &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11248</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11248"/>
		<updated>2026-09-10T14:21:55Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Hardware  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
Choix libres: &amp;lt;br&amp;gt;&lt;br /&gt;
_ alimentation de l&#039;ATmega32U4 en 3.3V plutôt qu&#039;en 5V  &amp;lt;br&amp;gt;&lt;br /&gt;
Cahier de charges :   &amp;lt;br&amp;gt;&lt;br /&gt;
_ Crystal de 8MHZ &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11247</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11247"/>
		<updated>2026-09-10T14:21:45Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Hardware  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
Choix libres: &amp;lt;br&amp;gt;&lt;br /&gt;
_ alimentation de l&#039;ATmega32U4 en 3.3V plutôt qu&#039;en 5V &lt;br /&gt;
&lt;br /&gt;
Cahier de charges :  &lt;br /&gt;
_ Crystal de 8MHZ&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11246</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11246"/>
		<updated>2026-09-10T14:21:27Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Hardware  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
Choix libres: ;&lt;br /&gt;
_ alimentation de l&#039;ATmega32U4 en 3.3V plutôt qu&#039;en 5V ;&lt;br /&gt;
&lt;br /&gt;
Cahier de charges :  ;&lt;br /&gt;
_ Crystal de 8MHZ ;&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11245</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11245"/>
		<updated>2026-09-10T14:21:13Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Carte mère  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
Choix libres:&lt;br /&gt;
_ alimentation de l&#039;ATmega32U4 en 3.3V plutôt qu&#039;en 5V&lt;br /&gt;
&lt;br /&gt;
Cahier de charges : &lt;br /&gt;
_ Crystal de 8MHZ&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11243</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11243"/>
		<updated>2026-09-10T14:12:12Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Software  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
- ATmega32U4 : servant à ...&lt;br /&gt;
&lt;br /&gt;
- ATmega16U2 : &lt;br /&gt;
&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- Regulateur de tension : footprint = MCP1640Bx-xCHY&lt;br /&gt;
- Crystal 8MHz : &lt;br /&gt;
- AT45DB641E&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11242</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11242"/>
		<updated>2026-09-10T14:11:50Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Hardware  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
=== &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&lt;br /&gt;
- ATmega32U4 : servant à ...&lt;br /&gt;
&lt;br /&gt;
- ATmega16U2 : &lt;br /&gt;
&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- Regulateur de tension : footprint = MCP1640Bx-xCHY&lt;br /&gt;
- Crystal 8MHz : &lt;br /&gt;
- AT45DB641E&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11241</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11241"/>
		<updated>2026-09-10T14:10:59Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /*  Objectifs  */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; =&lt;br /&gt;
- ATmega32U4 : servant à ...&lt;br /&gt;
&lt;br /&gt;
- ATmega16U2 : &lt;br /&gt;
&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- Regulateur de tension : footprint = MCP1640Bx-xCHY&lt;br /&gt;
- Crystal 8MHz : &lt;br /&gt;
- AT45DB641E&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11240</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11240"/>
		<updated>2026-09-10T14:10:41Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
[[Pico-ordinateur]]&lt;br /&gt;
&lt;br /&gt;
[[Pico SE4 2026/2027]]&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; =&lt;br /&gt;
- ATmega32U4 : servant à ...&lt;br /&gt;
&lt;br /&gt;
- ATmega16U2 : &lt;br /&gt;
&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- Regulateur de tension : footprint = MCP1640Bx-xCHY&lt;br /&gt;
- Crystal 8MHz : &lt;br /&gt;
- AT45DB641E&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11239</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11239"/>
		<updated>2026-09-10T14:10:12Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
[[Pico-ordinateur]]&lt;br /&gt;
&lt;br /&gt;
[[Pico SE4 2026/2027]]&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; =&lt;br /&gt;
- ATmega32U4 : servant à ...&lt;br /&gt;
&lt;br /&gt;
- ATmega16U2 : &lt;br /&gt;
&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- Regulateur de tension : footprint = MCP1640Bx-xCHY&lt;br /&gt;
- Crystal 8MHz : &lt;br /&gt;
- AT45DB641E&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#9D00FF;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11238</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11238"/>
		<updated>2026-09-10T14:09:24Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= &amp;lt;span style=&amp;quot;color:#DAB1DA;font-weight: bold;&amp;quot;&amp;gt; Objectifs &amp;lt;/span&amp;gt; =&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
[[Pico-ordinateur]]&lt;br /&gt;
&lt;br /&gt;
[[Pico SE4 2026/2027]]&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#DAB1DA;font-weight: bold;&amp;quot;&amp;gt; Lien GIT &amp;lt;/span&amp;gt; =&lt;br /&gt;
https://gitea.plil.fr/mterrier/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#DAB1DA;font-weight: bold;&amp;quot;&amp;gt; Carte mère &amp;lt;/span&amp;gt; =&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#DAB1DA;font-weight: bold;&amp;quot;&amp;gt; Hardware &amp;lt;/span&amp;gt; =&lt;br /&gt;
- ATmega32U4 : servant à ...&lt;br /&gt;
&lt;br /&gt;
- ATmega16U2 : &lt;br /&gt;
&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- Regulateur de tension : footprint = MCP1640Bx-xCHY&lt;br /&gt;
- Crystal 8MHz : &lt;br /&gt;
- AT45DB641E&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#DAB1DA;font-weight: bold;&amp;quot;&amp;gt; Software &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#DAB1DA;font-weight: bold;&amp;quot;&amp;gt; Carte filles &amp;lt;/span&amp;gt; =&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#DAB1DA;font-weight: bold;&amp;quot;&amp;gt; Ordonanceur &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#DAB1DA;font-weight: bold;&amp;quot;&amp;gt; Etapes clés &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#DAB1DA;font-weight: bold;&amp;quot;&amp;gt; Système de Fichiers &amp;lt;/span&amp;gt; =&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
= &amp;lt;span style=&amp;quot;color:#DAB1DA;font-weight: bold;&amp;quot;&amp;gt; Historique des scéances &amp;lt;/span&amp;gt; =&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-1&amp;diff=11237</id>
		<title>SE4Binome2026-1</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-1&amp;diff=11237"/>
		<updated>2026-09-10T13:56:58Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=== Cahier des charges ===&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère.&lt;br /&gt;
&lt;br /&gt;
[[Pico-ordinateur]]&lt;br /&gt;
&lt;br /&gt;
[[Pico SE4 2026/2027]]&lt;br /&gt;
&lt;br /&gt;
=== Lien GIT ===&lt;br /&gt;
https://gitea.plil.fr/tregaud/IOT4_Pico_Bouallegui_Reugo&lt;br /&gt;
&lt;br /&gt;
=== Carte mère ===&lt;br /&gt;
&lt;br /&gt;
==== Hardware ====&lt;br /&gt;
&lt;br /&gt;
===== Composants =====&lt;br /&gt;
- [x] ATmega32U4&lt;br /&gt;
&lt;br /&gt;
- [x] ATmega16U2&lt;br /&gt;
&lt;br /&gt;
- [ ] USB A : footprint = USB_A_Molex_48037-2200_Horizontal (male)&lt;br /&gt;
&lt;br /&gt;
- [ ] USB A : footprint = A verif si la meme pour femelle&lt;br /&gt;
&lt;br /&gt;
- [ ] USB C&lt;br /&gt;
&lt;br /&gt;
- [x] Regulateur de tension : footprint = MCP1640Bx-xCHY&lt;br /&gt;
&lt;br /&gt;
- [ ] Crystal 8MHz : footprint = Crystal_SDM_3223_4pin_3.2x2.5mm&lt;br /&gt;
&lt;br /&gt;
- [x] AT45DB641E&lt;br /&gt;
&lt;br /&gt;
==== Software ====&lt;br /&gt;
&lt;br /&gt;
=== Cartes filles ===&lt;br /&gt;
Les cartes filles peuvent être de différents types :&lt;br /&gt;
&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille d&#039;affichage ;&lt;br /&gt;
* carte fille série (se comporte comme un clavier et comme un dispositif d&#039;affichage) ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse (alternative à la mémoire de masse de la carte mère) ;&lt;br /&gt;
* carte fille son.&lt;br /&gt;
&lt;br /&gt;
A choisir plus tard...&lt;br /&gt;
&lt;br /&gt;
=== Ordonnanceur ===&lt;br /&gt;
&lt;br /&gt;
==== Etapes clés ====&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
=== Système de fichier ===&lt;br /&gt;
A voir plus tard&lt;br /&gt;
&lt;br /&gt;
=== Historique des séances ===&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Lecture du sujet&lt;br /&gt;
&lt;br /&gt;
Recherche des datasheets&lt;br /&gt;
&lt;br /&gt;
Installation Kicad 9&lt;br /&gt;
&lt;br /&gt;
Début du schéma dans Kicad&lt;br /&gt;
&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Amphi Ordonnanceur + Système de fichiers&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-1&amp;diff=11236</id>
		<title>SE4Binome2026-1</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-1&amp;diff=11236"/>
		<updated>2026-09-10T13:55:39Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Cartes filles */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=== Cahier des charges ===&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère.&lt;br /&gt;
&lt;br /&gt;
[[Pico-ordinateur]]&lt;br /&gt;
&lt;br /&gt;
[[Pico SE4 2026/2027]]&lt;br /&gt;
&lt;br /&gt;
=== Lien GIT ===&lt;br /&gt;
https://gitea.plil.fr/tregaud/IOT4_Pico_Bouallegui_Reugo&lt;br /&gt;
&lt;br /&gt;
=== Carte mère ===&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Hardware ===&lt;br /&gt;
ATmega32U4 : servant à ..&lt;br /&gt;
ATmega16U2 : servant à ...&lt;br /&gt;
&lt;br /&gt;
==== Software ====&lt;br /&gt;
&lt;br /&gt;
=== Cartes filles ===&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille d&#039;affichage ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse (alternative à la mémoire de masse de la carte mère) ;&lt;br /&gt;
* carte fille son.&lt;br /&gt;
&lt;br /&gt;
=== Ordonnanceur ===&lt;br /&gt;
&lt;br /&gt;
==== Etapes clés ====&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
=== Système de fichier ===&lt;br /&gt;
A voir plus tard&lt;br /&gt;
&lt;br /&gt;
=== Historique des séances ===&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Lecture du sujet&lt;br /&gt;
&lt;br /&gt;
Recherche des datasheets&lt;br /&gt;
&lt;br /&gt;
Installation Kicad 9&lt;br /&gt;
&lt;br /&gt;
Début du schéma dans Kicad&lt;br /&gt;
&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Amphi Ordonnanceur + Système de fichiers&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-1&amp;diff=11235</id>
		<title>SE4Binome2026-1</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-1&amp;diff=11235"/>
		<updated>2026-09-10T13:55:09Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* == Hardware */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=== Cahier des charges ===&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère.&lt;br /&gt;
&lt;br /&gt;
[[Pico-ordinateur]]&lt;br /&gt;
&lt;br /&gt;
[[Pico SE4 2026/2027]]&lt;br /&gt;
&lt;br /&gt;
=== Lien GIT ===&lt;br /&gt;
https://gitea.plil.fr/tregaud/IOT4_Pico_Bouallegui_Reugo&lt;br /&gt;
&lt;br /&gt;
=== Carte mère ===&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==== Hardware ===&lt;br /&gt;
ATmega32U4 : servant à ..&lt;br /&gt;
ATmega16U2 : servant à ...&lt;br /&gt;
&lt;br /&gt;
==== Software ====&lt;br /&gt;
&lt;br /&gt;
=== Cartes filles ===&lt;br /&gt;
Les cartes filles peuvent être de différents types :&lt;br /&gt;
&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille d&#039;affichage ;&lt;br /&gt;
* carte fille série (se comporte comme un clavier et comme un dispositif d&#039;affichage) ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse (alternative à la mémoire de masse de la carte mère) ;&lt;br /&gt;
* carte fille son.&lt;br /&gt;
&lt;br /&gt;
A choisir plus tard...&lt;br /&gt;
&lt;br /&gt;
=== Ordonnanceur ===&lt;br /&gt;
&lt;br /&gt;
==== Etapes clés ====&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
=== Système de fichier ===&lt;br /&gt;
A voir plus tard&lt;br /&gt;
&lt;br /&gt;
=== Historique des séances ===&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Lecture du sujet&lt;br /&gt;
&lt;br /&gt;
Recherche des datasheets&lt;br /&gt;
&lt;br /&gt;
Installation Kicad 9&lt;br /&gt;
&lt;br /&gt;
Début du schéma dans Kicad&lt;br /&gt;
&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Amphi Ordonnanceur + Système de fichiers&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-1&amp;diff=11234</id>
		<title>SE4Binome2026-1</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-1&amp;diff=11234"/>
		<updated>2026-09-10T13:54:59Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Hardware */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=== Cahier des charges ===&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère.&lt;br /&gt;
&lt;br /&gt;
[[Pico-ordinateur]]&lt;br /&gt;
&lt;br /&gt;
[[Pico SE4 2026/2027]]&lt;br /&gt;
&lt;br /&gt;
=== Lien GIT ===&lt;br /&gt;
https://gitea.plil.fr/tregaud/IOT4_Pico_Bouallegui_Reugo&lt;br /&gt;
&lt;br /&gt;
=== Carte mère ===&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
===== Hardware ===&lt;br /&gt;
ATmega32U4 : servant à ..&lt;br /&gt;
ATmega16U2 : servant à ...&lt;br /&gt;
&lt;br /&gt;
==== Software ====&lt;br /&gt;
&lt;br /&gt;
=== Cartes filles ===&lt;br /&gt;
Les cartes filles peuvent être de différents types :&lt;br /&gt;
&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille d&#039;affichage ;&lt;br /&gt;
* carte fille série (se comporte comme un clavier et comme un dispositif d&#039;affichage) ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse (alternative à la mémoire de masse de la carte mère) ;&lt;br /&gt;
* carte fille son.&lt;br /&gt;
&lt;br /&gt;
A choisir plus tard...&lt;br /&gt;
&lt;br /&gt;
=== Ordonnanceur ===&lt;br /&gt;
&lt;br /&gt;
==== Etapes clés ====&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
=== Système de fichier ===&lt;br /&gt;
A voir plus tard&lt;br /&gt;
&lt;br /&gt;
=== Historique des séances ===&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Lecture du sujet&lt;br /&gt;
&lt;br /&gt;
Recherche des datasheets&lt;br /&gt;
&lt;br /&gt;
Installation Kicad 9&lt;br /&gt;
&lt;br /&gt;
Début du schéma dans Kicad&lt;br /&gt;
&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Amphi Ordonnanceur + Système de fichiers&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-1&amp;diff=11233</id>
		<title>SE4Binome2026-1</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-1&amp;diff=11233"/>
		<updated>2026-09-10T13:54:14Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Hardware */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=== Cahier des charges ===&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère.&lt;br /&gt;
&lt;br /&gt;
[[Pico-ordinateur]]&lt;br /&gt;
&lt;br /&gt;
[[Pico SE4 2026/2027]]&lt;br /&gt;
&lt;br /&gt;
=== Lien GIT ===&lt;br /&gt;
https://gitea.plil.fr/tregaud/IOT4_Pico_Bouallegui_Reugo&lt;br /&gt;
&lt;br /&gt;
=== Carte mère ===&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
===== Hardware =====&lt;br /&gt;
- [x] ATmega32U4&lt;br /&gt;
&lt;br /&gt;
- [x] ATmega16U2&lt;br /&gt;
&lt;br /&gt;
- [ ] USB A : footprint = USB_A_Molex_48037-2200_Horizontal (male)&lt;br /&gt;
&lt;br /&gt;
- [ ] USB A : footprint = A verif si la meme pour femelle&lt;br /&gt;
&lt;br /&gt;
- [ ] USB C&lt;br /&gt;
&lt;br /&gt;
- [x] Regulateur de tension : footprint = MCP1640Bx-xCHY&lt;br /&gt;
&lt;br /&gt;
- [ ] Crystal 8MHz : footprint = Crystal_SDM_3223_4pin_3.2x2.5mm&lt;br /&gt;
&lt;br /&gt;
- [x] AT45DB641E&lt;br /&gt;
&lt;br /&gt;
==== Software ====&lt;br /&gt;
&lt;br /&gt;
=== Cartes filles ===&lt;br /&gt;
Les cartes filles peuvent être de différents types :&lt;br /&gt;
&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille d&#039;affichage ;&lt;br /&gt;
* carte fille série (se comporte comme un clavier et comme un dispositif d&#039;affichage) ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse (alternative à la mémoire de masse de la carte mère) ;&lt;br /&gt;
* carte fille son.&lt;br /&gt;
&lt;br /&gt;
A choisir plus tard...&lt;br /&gt;
&lt;br /&gt;
=== Ordonnanceur ===&lt;br /&gt;
&lt;br /&gt;
==== Etapes clés ====&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
=== Système de fichier ===&lt;br /&gt;
A voir plus tard&lt;br /&gt;
&lt;br /&gt;
=== Historique des séances ===&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Lecture du sujet&lt;br /&gt;
&lt;br /&gt;
Recherche des datasheets&lt;br /&gt;
&lt;br /&gt;
Installation Kicad 9&lt;br /&gt;
&lt;br /&gt;
Début du schéma dans Kicad&lt;br /&gt;
&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Amphi Ordonnanceur + Système de fichiers&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11231</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11231"/>
		<updated>2026-09-10T13:49:45Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=== Cahier des charges ===&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère accompagnée de ses cartes filles (son, réseaux, mémoire).&lt;br /&gt;
&lt;br /&gt;
[[Pico-ordinateur]]&lt;br /&gt;
&lt;br /&gt;
[[Pico SE4 2026/2027]]&lt;br /&gt;
&lt;br /&gt;
=== Lien GIT ===&lt;br /&gt;
https://gitea.plil.fr/tregaud/IOT4_Pico_TERRIER_RAMESH&lt;br /&gt;
&lt;br /&gt;
=== Carte mère ===&lt;br /&gt;
==== Hardware ====&lt;br /&gt;
&lt;br /&gt;
===== Composants =====&lt;br /&gt;
- ATmega32U4 : servant à ...&lt;br /&gt;
&lt;br /&gt;
- ATmega16U2 : &lt;br /&gt;
&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- USB A : footprint :&lt;br /&gt;
- Regulateur de tension : footprint = MCP1640Bx-xCHY&lt;br /&gt;
- Crystal 8MHz : &lt;br /&gt;
- AT45DB641E&lt;br /&gt;
&lt;br /&gt;
==== Software ====&lt;br /&gt;
&lt;br /&gt;
=== Cartes filles ===&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille écran ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse ;&lt;br /&gt;
* carte fille son&lt;br /&gt;
&lt;br /&gt;
=== Ordonnanceur ===&lt;br /&gt;
&lt;br /&gt;
==== Etapes clés ====&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
=== Système de fichier ===&lt;br /&gt;
trucs de bases (remplir après)&lt;br /&gt;
&lt;br /&gt;
=== Historique des séances ===&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Prise en conaissance du sujet et début de la schématique kicad&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Début de la programation pour les interruptions qui nous servirons pour l&#039;ordonanceur&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11229</id>
		<title>SE4Binome2026-6</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE4Binome2026-6&amp;diff=11229"/>
		<updated>2026-09-10T13:43:49Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : Page créée avec « === Cahier des charges === L&amp;#039;objectif est de réaliser une carte mère.  Pico-ordinateur  Pico SE4 2026/2027  === Lien GIT === https://gitea.plil.fr/tregaud/IOT4_Pico_Bouallegui_Reugo  === Carte mère ===  ==== Hardware ====  ===== Composants ===== - [x] ATmega32U4  - [x] ATmega16U2  - [ ] USB A : footprint = USB_A_Molex_48037-2200_Horizontal (male)  - [ ] USB A : footprint = A verif si la meme pour femelle  - [ ] USB C  - [x] Regulateur de tension : foot... »&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=== Cahier des charges ===&lt;br /&gt;
L&#039;objectif est de réaliser une carte mère.&lt;br /&gt;
&lt;br /&gt;
[[Pico-ordinateur]]&lt;br /&gt;
&lt;br /&gt;
[[Pico SE4 2026/2027]]&lt;br /&gt;
&lt;br /&gt;
=== Lien GIT ===&lt;br /&gt;
https://gitea.plil.fr/tregaud/IOT4_Pico_Bouallegui_Reugo&lt;br /&gt;
&lt;br /&gt;
=== Carte mère ===&lt;br /&gt;
&lt;br /&gt;
==== Hardware ====&lt;br /&gt;
&lt;br /&gt;
===== Composants =====&lt;br /&gt;
- [x] ATmega32U4&lt;br /&gt;
&lt;br /&gt;
- [x] ATmega16U2&lt;br /&gt;
&lt;br /&gt;
- [ ] USB A : footprint = USB_A_Molex_48037-2200_Horizontal (male)&lt;br /&gt;
&lt;br /&gt;
- [ ] USB A : footprint = A verif si la meme pour femelle&lt;br /&gt;
&lt;br /&gt;
- [ ] USB C&lt;br /&gt;
&lt;br /&gt;
- [x] Regulateur de tension : footprint = MCP1640Bx-xCHY&lt;br /&gt;
&lt;br /&gt;
- [ ] Crystal 8MHz : footprint = Crystal_SDM_3223_4pin_3.2x2.5mm&lt;br /&gt;
&lt;br /&gt;
- [x] AT45DB641E&lt;br /&gt;
&lt;br /&gt;
==== Software ====&lt;br /&gt;
&lt;br /&gt;
=== Cartes filles ===&lt;br /&gt;
Les cartes filles peuvent être de différents types :&lt;br /&gt;
&lt;br /&gt;
* carte fille clavier ;&lt;br /&gt;
* carte fille d&#039;affichage ;&lt;br /&gt;
* carte fille série (se comporte comme un clavier et comme un dispositif d&#039;affichage) ;&lt;br /&gt;
* carte fille réseau ;&lt;br /&gt;
* carte fille mémoire de masse (alternative à la mémoire de masse de la carte mère) ;&lt;br /&gt;
* carte fille son.&lt;br /&gt;
&lt;br /&gt;
A choisir plus tard...&lt;br /&gt;
&lt;br /&gt;
=== Ordonnanceur ===&lt;br /&gt;
&lt;br /&gt;
==== Etapes clés ====&lt;br /&gt;
&lt;br /&gt;
# Sauvegarder&lt;br /&gt;
# Ordonnancer&lt;br /&gt;
# Restaurer&lt;br /&gt;
&lt;br /&gt;
=== Système de fichier ===&lt;br /&gt;
A voir plus tard&lt;br /&gt;
&lt;br /&gt;
=== Historique des séances ===&lt;br /&gt;
&lt;br /&gt;
==== 08/09 : ====&lt;br /&gt;
Lecture du sujet&lt;br /&gt;
&lt;br /&gt;
Recherche des datasheets&lt;br /&gt;
&lt;br /&gt;
Installation Kicad 9&lt;br /&gt;
&lt;br /&gt;
Début du schéma dans Kicad&lt;br /&gt;
&lt;br /&gt;
==== 10/09 : ====&lt;br /&gt;
Amphi Ordonnanceur + Système de fichiers&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-3&amp;diff=10856</id>
		<title>SE3Groupe2025-3</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-3&amp;diff=10856"/>
		<updated>2026-06-14T20:11:50Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Programmation des systèmes embarqués */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Projet KiCAD rechargé avec un nom correct : [[file:2025-PSE-3-Prog.zip]]&lt;br /&gt;
&lt;br /&gt;
Début de correction, projet trop embryonnaire pour mériter une correction, terminez le schéma : [[file:2025-PSE-3-Prog-rex.zip]]&lt;br /&gt;
&lt;br /&gt;
Version finale du projet avec le routage : [[file:2025-PSE-3-Prog-Corrige.zip]]&lt;br /&gt;
&lt;br /&gt;
---------------------------------------&lt;br /&gt;
&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
L&#039;objectif est de concevoir et programmer une carte qui mesure le niveau sonore ambiant pour l&#039;afficher visuellement. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour cela, on utilise 7 LED qui font office d&#039;indicateur de niveau. Le principe est simple : le nombre de LED allumées dépend directement du volume capté. &amp;lt;br&amp;gt;&lt;br /&gt;
Chaque LED est associée à un seuil sonore. Plus le bruit augmente, plus on franchit de paliers, et donc plus on allume de LED. &amp;lt;br&amp;gt;&lt;br /&gt;
On passe ainsi d&#039;une seule LED allumée pour un bruit léger, jusqu&#039;aux 7 LED allumées en même temps lors d&#039;un pic sonore. &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B3-PROG.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
Schéma électronique de la carte :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-schema.pdf|thumb|center|400px|Mon schéma électronique]]&lt;br /&gt;
&lt;br /&gt;
Résultat du routage :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-PCB.png|thumb|center|400px|Mon routage]]&lt;br /&gt;
&lt;br /&gt;
Photo de la carte soudée :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-carte.jpg|thumb|center|400px|Ma carte]]&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-B3-PROG-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=;font-weight: bold;&amp;quot;&amp;gt;1) blink.c &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define BLINK_DELAY 250 // en ms&lt;br /&gt;
&lt;br /&gt;
// (PD0 = LED7, PD1-PD6 = LED1-LED6)&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // on def les led en sortie :&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
	  {&lt;br /&gt;
		// on allume les leds&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
		_delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
		// led off&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 0); // AND + NOT&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
		_delay_ms(BLINK_DELAY);&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;
== Bilan ==&lt;br /&gt;
&lt;br /&gt;
1ère séance  03/03: Recherche d&#039;idée de projet, Mise en place du projet,  début de reflexion sur le schéma éléctronique.&lt;br /&gt;
&lt;br /&gt;
2e séance  10/03: Début de réalisation du schéma électronique &lt;br /&gt;
&lt;br /&gt;
3e scéance  17/03: Continuation du schéma &lt;br /&gt;
&lt;br /&gt;
4e scéance  24/03: Correction du schéma&lt;br /&gt;
&lt;br /&gt;
5e scéance  31/03: Fin de la réalisation du schéma &lt;br /&gt;
&lt;br /&gt;
7e scéance 28/04 : &lt;br /&gt;
&lt;br /&gt;
8e scéance 05/05 : Soudure (pas trop eu accès aux fers) &lt;br /&gt;
&lt;br /&gt;
9e scéance 12/05 : Soudure&lt;br /&gt;
&lt;br /&gt;
10e scéance 19/05: Correction de la soudure ( LED soudé à l&#039;envers)&lt;br /&gt;
&lt;br /&gt;
11e scéance 26/05 :test des LED + début de programmation  &lt;br /&gt;
&lt;br /&gt;
12e scéance (bonus)02/06: soudure final } programmation &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Eventuellement la vidéo brève du fonctionnement complet du programmateur : [[Média:2025-PSE-B3-PROG-final.mp4]].&lt;br /&gt;
&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Mon archive GIT pour le projet KiCAD et pour les programmes : [https://gitea.plil.fr/stazani/2025_PSE_B3_stazani_lkachour.git].&lt;br /&gt;
&lt;br /&gt;
Archive privée. Binôme comme administrateur. Boé et Redon comme administrateur.&lt;br /&gt;
&lt;br /&gt;
Ajouter un &amp;lt;code&amp;gt;.gitignore&amp;lt;/code&amp;gt; pour KiCAD et langage C.&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
&#039;&#039;&#039;Objectif :&#039;&#039;&#039; Réaliser un système embarqué capable de mesurer le niveau sonore à l&#039;aide d&#039;un microphone et d&#039;afficher visuellement l&#039;intensité du son à l&#039;aide de LEDs de couleurs (vertes, oranges, rouges).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Travail effectué ==&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Journal de bord&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;1&amp;lt;sup&amp;gt;ère&amp;lt;/sup&amp;gt; séance — 03/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé par chercher une idée de projet et voir ce qu’on pouvait faire comme système embarqué. On a aussi commencé à mettre en place le projet, avec l’organisation du Git et les premières idées pour la carte. &lt;br /&gt;
&lt;br /&gt;
On a commencé à réfléchir au schéma électronique, surtout sur les composants principaux, les LED et les broches qu’on allait utiliser.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;2&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 10/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé la réalisation du schéma électronique sur KiCad. &lt;br /&gt;
&lt;br /&gt;
On a placé les premiers composants et on a commencé à faire les connexions. Le but était surtout de poser les bases de la carte et de voir comment relier les différents éléments entre eux.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;3&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 17/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a continué le schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a avancé sur les connexions et on a vérifié que les broches utilisées étaient cohérentes avec ce qu’on voulait faire. On a aussi commencé à faire attention aux LED et à leur branchement, pour pouvoir les tester après.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;4&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 24/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a corrigé le schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a regardé les erreurs possibles dans KiCad, comme les connexions oubliées ou les signaux mal reliés. On a aussi corrigé certaines parties du schéma pour que la carte soit plus propre avant de passer à la suite.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;5&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 31/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a fini la réalisation du schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a fait les dernières corrections et vérifications pour avoir un schéma utilisable. À la fin de cette séance, la partie schéma était quasiment terminée et prête pour la partie matérielle.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;6&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Séance non renseignée.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;7&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 28/04&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a repris le projet et on a préparé la partie matérielle. &lt;br /&gt;
&lt;br /&gt;
On a vérifié la carte et les composants avant de commencer vraiment la soudure. Le but était de s’assurer qu’on pouvait assembler la carte correctement et qu’il ne manquait pas d’éléments importants.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;8&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 05/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé la soudure des composants sur la carte. &lt;br /&gt;
&lt;br /&gt;
On n’a pas eu beaucoup accès aux fers à souder donc on n’a pas pu avancer autant que prévu, mais on a quand même commencé l’assemblage. Cette séance nous a permis de passer du schéma KiCad à la carte réelle.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;9&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 12/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a continué la soudure sur la carte. &lt;br /&gt;
&lt;br /&gt;
On a soudé d’autres composants et on a essayé de faire attention au sens des composants, surtout les LED. On a aussi regardé les soudures pour éviter les faux contacts ou les courts-circuits.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;10&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 19/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a corrigé la soudure de la carte. &lt;br /&gt;
&lt;br /&gt;
On s’est rendu compte qu’une LED avait été soudée à l’envers, donc elle ne pouvait pas fonctionner correctement. On l’a donc dessoudée puis ressoudée dans le bon sens. Ça nous a permis de mieux comprendre l’importance de la polarité des LED.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;11&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 26/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé les tests des LED et le début de la programmation. &lt;br /&gt;
&lt;br /&gt;
Le but était de vérifier si les LED s’allumaient correctement après la soudure. On a surtout travaillé sur la LED reliée à la broche 26. &lt;br /&gt;
&lt;br /&gt;
On a aussi commencé à faire un programme simple pour configurer la broche en sortie et faire clignoter la LED. Cette séance a permis de faire le lien entre la carte électronique et le programme en C.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;12&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance bonus — 02/06&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a terminé les dernières soudures de la carte et on a continué la programmation. &lt;br /&gt;
&lt;br /&gt;
On a fait les tests finaux pour vérifier que les LED fonctionnaient bien. Le programme permettait d’allumer et d’éteindre la LED avec un délai, pour voir si la broche 26 était bien commandée. &lt;br /&gt;
&lt;br /&gt;
Cette séance nous a permis de finaliser la partie matérielle et de valider les premiers tests du logiciel.&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&lt;br /&gt;
Eventuellement la vidéo brève du fonctionnement complet du programmateur : [[Média:2025-PSE-B3-systeme-final.mp4]].&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-3&amp;diff=10854</id>
		<title>SE3Groupe2025-3</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-3&amp;diff=10854"/>
		<updated>2026-06-14T20:11:20Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Programmation des systèmes embarqués */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Projet KiCAD rechargé avec un nom correct : [[file:2025-PSE-3-Prog.zip]]&lt;br /&gt;
&lt;br /&gt;
Début de correction, projet trop embryonnaire pour mériter une correction, terminez le schéma : [[file:2025-PSE-3-Prog-rex.zip]]&lt;br /&gt;
&lt;br /&gt;
Version finale du projet avec le routage : [[file:2025-PSE-3-Prog-Corrige.zip]]&lt;br /&gt;
&lt;br /&gt;
---------------------------------------&lt;br /&gt;
&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
L&#039;objectif est de concevoir et programmer une carte qui mesure le niveau sonore ambiant pour l&#039;afficher visuellement.&lt;br /&gt;
Pour cela, on utilise 7 LED qui font office d&#039;indicateur de niveau. Le principe est simple : le nombre de LED allumées dépend directement du volume capté. &lt;br /&gt;
Chaque LED est associée à un seuil sonore. Plus le bruit augmente, plus on franchit de paliers, et donc plus on allume de LED. &lt;br /&gt;
On passe ainsi d&#039;une seule LED allumée pour un bruit léger, jusqu&#039;aux 7 LED allumées en même temps lors d&#039;un pic sonore.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B3-PROG.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
Schéma électronique de la carte :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-schema.pdf|thumb|center|400px|Mon schéma électronique]]&lt;br /&gt;
&lt;br /&gt;
Résultat du routage :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-PCB.png|thumb|center|400px|Mon routage]]&lt;br /&gt;
&lt;br /&gt;
Photo de la carte soudée :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-carte.jpg|thumb|center|400px|Ma carte]]&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-B3-PROG-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=;font-weight: bold;&amp;quot;&amp;gt;1) blink.c &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define BLINK_DELAY 250 // en ms&lt;br /&gt;
&lt;br /&gt;
// (PD0 = LED7, PD1-PD6 = LED1-LED6)&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // on def les led en sortie :&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
	  {&lt;br /&gt;
		// on allume les leds&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
		_delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
		// led off&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 0); // AND + NOT&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
		_delay_ms(BLINK_DELAY);&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;
== Bilan ==&lt;br /&gt;
&lt;br /&gt;
1ère séance  03/03: Recherche d&#039;idée de projet, Mise en place du projet,  début de reflexion sur le schéma éléctronique.&lt;br /&gt;
&lt;br /&gt;
2e séance  10/03: Début de réalisation du schéma électronique &lt;br /&gt;
&lt;br /&gt;
3e scéance  17/03: Continuation du schéma &lt;br /&gt;
&lt;br /&gt;
4e scéance  24/03: Correction du schéma&lt;br /&gt;
&lt;br /&gt;
5e scéance  31/03: Fin de la réalisation du schéma &lt;br /&gt;
&lt;br /&gt;
7e scéance 28/04 : &lt;br /&gt;
&lt;br /&gt;
8e scéance 05/05 : Soudure (pas trop eu accès aux fers) &lt;br /&gt;
&lt;br /&gt;
9e scéance 12/05 : Soudure&lt;br /&gt;
&lt;br /&gt;
10e scéance 19/05: Correction de la soudure ( LED soudé à l&#039;envers)&lt;br /&gt;
&lt;br /&gt;
11e scéance 26/05 :test des LED + début de programmation  &lt;br /&gt;
&lt;br /&gt;
12e scéance (bonus)02/06: soudure final } programmation &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Eventuellement la vidéo brève du fonctionnement complet du programmateur : [[Média:2025-PSE-B3-PROG-final.mp4]].&lt;br /&gt;
&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Mon archive GIT pour le projet KiCAD et pour les programmes : [https://gitea.plil.fr/stazani/2025_PSE_B3_stazani_lkachour.git].&lt;br /&gt;
&lt;br /&gt;
Archive privée. Binôme comme administrateur. Boé et Redon comme administrateur.&lt;br /&gt;
&lt;br /&gt;
Ajouter un &amp;lt;code&amp;gt;.gitignore&amp;lt;/code&amp;gt; pour KiCAD et langage C.&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
&#039;&#039;&#039;Objectif :&#039;&#039;&#039; Réaliser un système embarqué capable de mesurer le niveau sonore à l&#039;aide d&#039;un microphone et d&#039;afficher visuellement l&#039;intensité du son à l&#039;aide de LEDs de couleurs (vertes, oranges, rouges).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Travail effectué ==&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Journal de bord&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;1&amp;lt;sup&amp;gt;ère&amp;lt;/sup&amp;gt; séance — 03/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé par chercher une idée de projet et voir ce qu’on pouvait faire comme système embarqué. On a aussi commencé à mettre en place le projet, avec l’organisation du Git et les premières idées pour la carte. &lt;br /&gt;
&lt;br /&gt;
On a commencé à réfléchir au schéma électronique, surtout sur les composants principaux, les LED et les broches qu’on allait utiliser.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;2&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 10/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé la réalisation du schéma électronique sur KiCad. &lt;br /&gt;
&lt;br /&gt;
On a placé les premiers composants et on a commencé à faire les connexions. Le but était surtout de poser les bases de la carte et de voir comment relier les différents éléments entre eux.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;3&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 17/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a continué le schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a avancé sur les connexions et on a vérifié que les broches utilisées étaient cohérentes avec ce qu’on voulait faire. On a aussi commencé à faire attention aux LED et à leur branchement, pour pouvoir les tester après.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;4&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 24/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a corrigé le schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a regardé les erreurs possibles dans KiCad, comme les connexions oubliées ou les signaux mal reliés. On a aussi corrigé certaines parties du schéma pour que la carte soit plus propre avant de passer à la suite.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;5&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 31/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a fini la réalisation du schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a fait les dernières corrections et vérifications pour avoir un schéma utilisable. À la fin de cette séance, la partie schéma était quasiment terminée et prête pour la partie matérielle.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;6&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Séance non renseignée.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;7&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 28/04&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a repris le projet et on a préparé la partie matérielle. &lt;br /&gt;
&lt;br /&gt;
On a vérifié la carte et les composants avant de commencer vraiment la soudure. Le but était de s’assurer qu’on pouvait assembler la carte correctement et qu’il ne manquait pas d’éléments importants.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;8&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 05/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé la soudure des composants sur la carte. &lt;br /&gt;
&lt;br /&gt;
On n’a pas eu beaucoup accès aux fers à souder donc on n’a pas pu avancer autant que prévu, mais on a quand même commencé l’assemblage. Cette séance nous a permis de passer du schéma KiCad à la carte réelle.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;9&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 12/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a continué la soudure sur la carte. &lt;br /&gt;
&lt;br /&gt;
On a soudé d’autres composants et on a essayé de faire attention au sens des composants, surtout les LED. On a aussi regardé les soudures pour éviter les faux contacts ou les courts-circuits.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;10&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 19/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a corrigé la soudure de la carte. &lt;br /&gt;
&lt;br /&gt;
On s’est rendu compte qu’une LED avait été soudée à l’envers, donc elle ne pouvait pas fonctionner correctement. On l’a donc dessoudée puis ressoudée dans le bon sens. Ça nous a permis de mieux comprendre l’importance de la polarité des LED.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;11&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 26/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé les tests des LED et le début de la programmation. &lt;br /&gt;
&lt;br /&gt;
Le but était de vérifier si les LED s’allumaient correctement après la soudure. On a surtout travaillé sur la LED reliée à la broche 26. &lt;br /&gt;
&lt;br /&gt;
On a aussi commencé à faire un programme simple pour configurer la broche en sortie et faire clignoter la LED. Cette séance a permis de faire le lien entre la carte électronique et le programme en C.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;12&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance bonus — 02/06&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a terminé les dernières soudures de la carte et on a continué la programmation. &lt;br /&gt;
&lt;br /&gt;
On a fait les tests finaux pour vérifier que les LED fonctionnaient bien. Le programme permettait d’allumer et d’éteindre la LED avec un délai, pour voir si la broche 26 était bien commandée. &lt;br /&gt;
&lt;br /&gt;
Cette séance nous a permis de finaliser la partie matérielle et de valider les premiers tests du logiciel.&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&lt;br /&gt;
Eventuellement la vidéo brève du fonctionnement complet du programmateur : [[Média:2025-PSE-B3-systeme-final.mp4]].&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-3&amp;diff=10853</id>
		<title>SE3Groupe2025-3</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-3&amp;diff=10853"/>
		<updated>2026-06-14T20:11:03Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Programmation des systèmes embarqués */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Projet KiCAD rechargé avec un nom correct : [[file:2025-PSE-3-Prog.zip]]&lt;br /&gt;
&lt;br /&gt;
Début de correction, projet trop embryonnaire pour mériter une correction, terminez le schéma : [[file:2025-PSE-3-Prog-rex.zip]]&lt;br /&gt;
&lt;br /&gt;
Version finale du projet avec le routage : [[file:2025-PSE-3-Prog-Corrige.zip]]&lt;br /&gt;
&lt;br /&gt;
---------------------------------------&lt;br /&gt;
&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
L&#039;objectif est de concevoir et programmer une carte qui mesure le niveau sonore ambiant pour l&#039;afficher visuellement.&lt;br /&gt;
 Pour cela, on utilise 7 LED qui font office d&#039;indicateur de niveau. Le principe est simple : le nombre de LED allumées dépend directement du volume capté. &lt;br /&gt;
Chaque LED est associée à un seuil sonore. Plus le bruit augmente, plus on franchit de paliers, et donc plus on allume de LED. &lt;br /&gt;
On passe ainsi d&#039;une seule LED allumée pour un bruit léger, jusqu&#039;aux 7 LED allumées en même temps lors d&#039;un pic sonore.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B3-PROG.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
Schéma électronique de la carte :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-schema.pdf|thumb|center|400px|Mon schéma électronique]]&lt;br /&gt;
&lt;br /&gt;
Résultat du routage :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-PCB.png|thumb|center|400px|Mon routage]]&lt;br /&gt;
&lt;br /&gt;
Photo de la carte soudée :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-carte.jpg|thumb|center|400px|Ma carte]]&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-B3-PROG-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=;font-weight: bold;&amp;quot;&amp;gt;1) blink.c &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define BLINK_DELAY 250 // en ms&lt;br /&gt;
&lt;br /&gt;
// (PD0 = LED7, PD1-PD6 = LED1-LED6)&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // on def les led en sortie :&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
	  {&lt;br /&gt;
		// on allume les leds&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
		_delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
		// led off&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 0); // AND + NOT&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
		_delay_ms(BLINK_DELAY);&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;
== Bilan ==&lt;br /&gt;
&lt;br /&gt;
1ère séance  03/03: Recherche d&#039;idée de projet, Mise en place du projet,  début de reflexion sur le schéma éléctronique.&lt;br /&gt;
&lt;br /&gt;
2e séance  10/03: Début de réalisation du schéma électronique &lt;br /&gt;
&lt;br /&gt;
3e scéance  17/03: Continuation du schéma &lt;br /&gt;
&lt;br /&gt;
4e scéance  24/03: Correction du schéma&lt;br /&gt;
&lt;br /&gt;
5e scéance  31/03: Fin de la réalisation du schéma &lt;br /&gt;
&lt;br /&gt;
7e scéance 28/04 : &lt;br /&gt;
&lt;br /&gt;
8e scéance 05/05 : Soudure (pas trop eu accès aux fers) &lt;br /&gt;
&lt;br /&gt;
9e scéance 12/05 : Soudure&lt;br /&gt;
&lt;br /&gt;
10e scéance 19/05: Correction de la soudure ( LED soudé à l&#039;envers)&lt;br /&gt;
&lt;br /&gt;
11e scéance 26/05 :test des LED + début de programmation  &lt;br /&gt;
&lt;br /&gt;
12e scéance (bonus)02/06: soudure final } programmation &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Eventuellement la vidéo brève du fonctionnement complet du programmateur : [[Média:2025-PSE-B3-PROG-final.mp4]].&lt;br /&gt;
&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Mon archive GIT pour le projet KiCAD et pour les programmes : [https://gitea.plil.fr/stazani/2025_PSE_B3_stazani_lkachour.git].&lt;br /&gt;
&lt;br /&gt;
Archive privée. Binôme comme administrateur. Boé et Redon comme administrateur.&lt;br /&gt;
&lt;br /&gt;
Ajouter un &amp;lt;code&amp;gt;.gitignore&amp;lt;/code&amp;gt; pour KiCAD et langage C.&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
&#039;&#039;&#039;Objectif :&#039;&#039;&#039; Réaliser un système embarqué capable de mesurer le niveau sonore à l&#039;aide d&#039;un microphone et d&#039;afficher visuellement l&#039;intensité du son à l&#039;aide de LEDs de couleurs (vertes, oranges, rouges).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Travail effectué ==&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Journal de bord&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;1&amp;lt;sup&amp;gt;ère&amp;lt;/sup&amp;gt; séance — 03/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé par chercher une idée de projet et voir ce qu’on pouvait faire comme système embarqué. On a aussi commencé à mettre en place le projet, avec l’organisation du Git et les premières idées pour la carte. &lt;br /&gt;
&lt;br /&gt;
On a commencé à réfléchir au schéma électronique, surtout sur les composants principaux, les LED et les broches qu’on allait utiliser.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;2&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 10/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé la réalisation du schéma électronique sur KiCad. &lt;br /&gt;
&lt;br /&gt;
On a placé les premiers composants et on a commencé à faire les connexions. Le but était surtout de poser les bases de la carte et de voir comment relier les différents éléments entre eux.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;3&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 17/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a continué le schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a avancé sur les connexions et on a vérifié que les broches utilisées étaient cohérentes avec ce qu’on voulait faire. On a aussi commencé à faire attention aux LED et à leur branchement, pour pouvoir les tester après.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;4&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 24/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a corrigé le schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a regardé les erreurs possibles dans KiCad, comme les connexions oubliées ou les signaux mal reliés. On a aussi corrigé certaines parties du schéma pour que la carte soit plus propre avant de passer à la suite.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;5&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 31/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a fini la réalisation du schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a fait les dernières corrections et vérifications pour avoir un schéma utilisable. À la fin de cette séance, la partie schéma était quasiment terminée et prête pour la partie matérielle.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;6&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Séance non renseignée.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;7&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 28/04&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a repris le projet et on a préparé la partie matérielle. &lt;br /&gt;
&lt;br /&gt;
On a vérifié la carte et les composants avant de commencer vraiment la soudure. Le but était de s’assurer qu’on pouvait assembler la carte correctement et qu’il ne manquait pas d’éléments importants.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;8&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 05/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé la soudure des composants sur la carte. &lt;br /&gt;
&lt;br /&gt;
On n’a pas eu beaucoup accès aux fers à souder donc on n’a pas pu avancer autant que prévu, mais on a quand même commencé l’assemblage. Cette séance nous a permis de passer du schéma KiCad à la carte réelle.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;9&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 12/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a continué la soudure sur la carte. &lt;br /&gt;
&lt;br /&gt;
On a soudé d’autres composants et on a essayé de faire attention au sens des composants, surtout les LED. On a aussi regardé les soudures pour éviter les faux contacts ou les courts-circuits.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;10&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 19/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a corrigé la soudure de la carte. &lt;br /&gt;
&lt;br /&gt;
On s’est rendu compte qu’une LED avait été soudée à l’envers, donc elle ne pouvait pas fonctionner correctement. On l’a donc dessoudée puis ressoudée dans le bon sens. Ça nous a permis de mieux comprendre l’importance de la polarité des LED.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;11&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 26/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé les tests des LED et le début de la programmation. &lt;br /&gt;
&lt;br /&gt;
Le but était de vérifier si les LED s’allumaient correctement après la soudure. On a surtout travaillé sur la LED reliée à la broche 26. &lt;br /&gt;
&lt;br /&gt;
On a aussi commencé à faire un programme simple pour configurer la broche en sortie et faire clignoter la LED. Cette séance a permis de faire le lien entre la carte électronique et le programme en C.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;12&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance bonus — 02/06&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a terminé les dernières soudures de la carte et on a continué la programmation. &lt;br /&gt;
&lt;br /&gt;
On a fait les tests finaux pour vérifier que les LED fonctionnaient bien. Le programme permettait d’allumer et d’éteindre la LED avec un délai, pour voir si la broche 26 était bien commandée. &lt;br /&gt;
&lt;br /&gt;
Cette séance nous a permis de finaliser la partie matérielle et de valider les premiers tests du logiciel.&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&lt;br /&gt;
Eventuellement la vidéo brève du fonctionnement complet du programmateur : [[Média:2025-PSE-B3-systeme-final.mp4]].&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-3&amp;diff=10852</id>
		<title>SE3Groupe2025-3</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-3&amp;diff=10852"/>
		<updated>2026-06-14T20:10:44Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Programmation des systèmes embarqués */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Projet KiCAD rechargé avec un nom correct : [[file:2025-PSE-3-Prog.zip]]&lt;br /&gt;
&lt;br /&gt;
Début de correction, projet trop embryonnaire pour mériter une correction, terminez le schéma : [[file:2025-PSE-3-Prog-rex.zip]]&lt;br /&gt;
&lt;br /&gt;
Version finale du projet avec le routage : [[file:2025-PSE-3-Prog-Corrige.zip]]&lt;br /&gt;
&lt;br /&gt;
---------------------------------------&lt;br /&gt;
&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
L&#039;objectif est de concevoir et programmer une carte qui mesure le niveau sonore ambiant pour l&#039;afficher visuellement. Pour cela, on utilise 7 LED qui font office d&#039;indicateur de niveau. Le principe est simple : le nombre de LED allumées dépend directement du volume capté. Chaque LED est associée à un seuil sonore. Plus le bruit augmente, plus on franchit de paliers, et donc plus on allume de LED. On passe ainsi d&#039;une seule LED allumée pour un bruit léger, jusqu&#039;aux 7 LED allumées en même temps lors d&#039;un pic sonore.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B3-PROG.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
Schéma électronique de la carte :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-schema.pdf|thumb|center|400px|Mon schéma électronique]]&lt;br /&gt;
&lt;br /&gt;
Résultat du routage :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-PCB.png|thumb|center|400px|Mon routage]]&lt;br /&gt;
&lt;br /&gt;
Photo de la carte soudée :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-carte.jpg|thumb|center|400px|Ma carte]]&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-B3-PROG-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=;font-weight: bold;&amp;quot;&amp;gt;1) blink.c &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define BLINK_DELAY 250 // en ms&lt;br /&gt;
&lt;br /&gt;
// (PD0 = LED7, PD1-PD6 = LED1-LED6)&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // on def les led en sortie :&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
	  {&lt;br /&gt;
		// on allume les leds&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
		_delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
		// led off&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 0); // AND + NOT&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
		_delay_ms(BLINK_DELAY);&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;
== Bilan ==&lt;br /&gt;
&lt;br /&gt;
1ère séance  03/03: Recherche d&#039;idée de projet, Mise en place du projet,  début de reflexion sur le schéma éléctronique.&lt;br /&gt;
&lt;br /&gt;
2e séance  10/03: Début de réalisation du schéma électronique &lt;br /&gt;
&lt;br /&gt;
3e scéance  17/03: Continuation du schéma &lt;br /&gt;
&lt;br /&gt;
4e scéance  24/03: Correction du schéma&lt;br /&gt;
&lt;br /&gt;
5e scéance  31/03: Fin de la réalisation du schéma &lt;br /&gt;
&lt;br /&gt;
7e scéance 28/04 : &lt;br /&gt;
&lt;br /&gt;
8e scéance 05/05 : Soudure (pas trop eu accès aux fers) &lt;br /&gt;
&lt;br /&gt;
9e scéance 12/05 : Soudure&lt;br /&gt;
&lt;br /&gt;
10e scéance 19/05: Correction de la soudure ( LED soudé à l&#039;envers)&lt;br /&gt;
&lt;br /&gt;
11e scéance 26/05 :test des LED + début de programmation  &lt;br /&gt;
&lt;br /&gt;
12e scéance (bonus)02/06: soudure final } programmation &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Eventuellement la vidéo brève du fonctionnement complet du programmateur : [[Média:2025-PSE-B3-PROG-final.mp4]].&lt;br /&gt;
&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Mon archive GIT pour le projet KiCAD et pour les programmes : [https://gitea.plil.fr/stazani/2025_PSE_B3_stazani_lkachour.git].&lt;br /&gt;
&lt;br /&gt;
Archive privée. Binôme comme administrateur. Boé et Redon comme administrateur.&lt;br /&gt;
&lt;br /&gt;
Ajouter un &amp;lt;code&amp;gt;.gitignore&amp;lt;/code&amp;gt; pour KiCAD et langage C.&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
&#039;&#039;&#039;Objectif :&#039;&#039;&#039; Réaliser un système embarqué capable de mesurer le niveau sonore à l&#039;aide d&#039;un microphone et d&#039;afficher visuellement l&#039;intensité du son à l&#039;aide de LEDs de couleurs (vertes, oranges, rouges).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Travail effectué ==&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Journal de bord&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;1&amp;lt;sup&amp;gt;ère&amp;lt;/sup&amp;gt; séance — 03/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé par chercher une idée de projet et voir ce qu’on pouvait faire comme système embarqué. On a aussi commencé à mettre en place le projet, avec l’organisation du Git et les premières idées pour la carte. &lt;br /&gt;
&lt;br /&gt;
On a commencé à réfléchir au schéma électronique, surtout sur les composants principaux, les LED et les broches qu’on allait utiliser.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;2&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 10/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé la réalisation du schéma électronique sur KiCad. &lt;br /&gt;
&lt;br /&gt;
On a placé les premiers composants et on a commencé à faire les connexions. Le but était surtout de poser les bases de la carte et de voir comment relier les différents éléments entre eux.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;3&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 17/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a continué le schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a avancé sur les connexions et on a vérifié que les broches utilisées étaient cohérentes avec ce qu’on voulait faire. On a aussi commencé à faire attention aux LED et à leur branchement, pour pouvoir les tester après.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;4&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 24/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a corrigé le schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a regardé les erreurs possibles dans KiCad, comme les connexions oubliées ou les signaux mal reliés. On a aussi corrigé certaines parties du schéma pour que la carte soit plus propre avant de passer à la suite.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;5&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 31/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a fini la réalisation du schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a fait les dernières corrections et vérifications pour avoir un schéma utilisable. À la fin de cette séance, la partie schéma était quasiment terminée et prête pour la partie matérielle.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;6&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Séance non renseignée.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;7&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 28/04&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a repris le projet et on a préparé la partie matérielle. &lt;br /&gt;
&lt;br /&gt;
On a vérifié la carte et les composants avant de commencer vraiment la soudure. Le but était de s’assurer qu’on pouvait assembler la carte correctement et qu’il ne manquait pas d’éléments importants.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;8&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 05/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé la soudure des composants sur la carte. &lt;br /&gt;
&lt;br /&gt;
On n’a pas eu beaucoup accès aux fers à souder donc on n’a pas pu avancer autant que prévu, mais on a quand même commencé l’assemblage. Cette séance nous a permis de passer du schéma KiCad à la carte réelle.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;9&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 12/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a continué la soudure sur la carte. &lt;br /&gt;
&lt;br /&gt;
On a soudé d’autres composants et on a essayé de faire attention au sens des composants, surtout les LED. On a aussi regardé les soudures pour éviter les faux contacts ou les courts-circuits.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;10&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 19/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a corrigé la soudure de la carte. &lt;br /&gt;
&lt;br /&gt;
On s’est rendu compte qu’une LED avait été soudée à l’envers, donc elle ne pouvait pas fonctionner correctement. On l’a donc dessoudée puis ressoudée dans le bon sens. Ça nous a permis de mieux comprendre l’importance de la polarité des LED.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;11&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 26/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé les tests des LED et le début de la programmation. &lt;br /&gt;
&lt;br /&gt;
Le but était de vérifier si les LED s’allumaient correctement après la soudure. On a surtout travaillé sur la LED reliée à la broche 26. &lt;br /&gt;
&lt;br /&gt;
On a aussi commencé à faire un programme simple pour configurer la broche en sortie et faire clignoter la LED. Cette séance a permis de faire le lien entre la carte électronique et le programme en C.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;12&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance bonus — 02/06&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a terminé les dernières soudures de la carte et on a continué la programmation. &lt;br /&gt;
&lt;br /&gt;
On a fait les tests finaux pour vérifier que les LED fonctionnaient bien. Le programme permettait d’allumer et d’éteindre la LED avec un délai, pour voir si la broche 26 était bien commandée. &lt;br /&gt;
&lt;br /&gt;
Cette séance nous a permis de finaliser la partie matérielle et de valider les premiers tests du logiciel.&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&lt;br /&gt;
Eventuellement la vidéo brève du fonctionnement complet du programmateur : [[Média:2025-PSE-B3-systeme-final.mp4]].&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-3&amp;diff=10850</id>
		<title>SE3Groupe2025-3</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-3&amp;diff=10850"/>
		<updated>2026-06-14T20:06:37Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Travail effectué */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Projet KiCAD rechargé avec un nom correct : [[file:2025-PSE-3-Prog.zip]]&lt;br /&gt;
&lt;br /&gt;
Début de correction, projet trop embryonnaire pour mériter une correction, terminez le schéma : [[file:2025-PSE-3-Prog-rex.zip]]&lt;br /&gt;
&lt;br /&gt;
Version finale du projet avec le routage : [[file:2025-PSE-3-Prog-Corrige.zip]]&lt;br /&gt;
&lt;br /&gt;
---------------------------------------&lt;br /&gt;
&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
Objectif : &amp;lt;br&amp;gt;&lt;br /&gt;
Réaliser une carte permettant de mesurer l&#039;intensité sonore et d&#039;allumer + ou - de leds en fonctions des decibels. &amp;lt;br&amp;gt;&lt;br /&gt;
Avec un total de 7 leds, chaque led s&#039;allume à partir d&#039;un certain niveau sonore. 1 led pour quelques décibels et 7 leds pour un niveau supérieur à 80db. &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B3-PROG.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
Schéma électronique de la carte :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-schema.pdf|thumb|center|400px|Mon schéma électronique]]&lt;br /&gt;
&lt;br /&gt;
Résultat du routage :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-PCB.png|thumb|center|400px|Mon routage]]&lt;br /&gt;
&lt;br /&gt;
Photo de la carte soudée :&lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B3-PROG-carte.jpg|thumb|center|400px|Ma carte]]&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-B3-PROG-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
&lt;br /&gt;
=== &amp;lt;span style=;font-weight: bold;&amp;quot;&amp;gt;1) blink.c &amp;lt;/span&amp;gt; ===&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define BLINK_DELAY 250 // en ms&lt;br /&gt;
&lt;br /&gt;
// (PD0 = LED7, PD1-PD6 = LED1-LED6)&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // on def les led en sortie :&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
  DDRD |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
	  {&lt;br /&gt;
		// on allume les leds&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
		PORTD |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
		_delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
		// led off&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 0); // AND + NOT&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 1);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 2);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 3);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
		PORTD &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
		_delay_ms(BLINK_DELAY);&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;
== Bilan ==&lt;br /&gt;
&lt;br /&gt;
1ère séance  03/03: Recherche d&#039;idée de projet, Mise en place du projet,  début de reflexion sur le schéma éléctronique.&lt;br /&gt;
&lt;br /&gt;
2e séance  10/03: Début de réalisation du schéma électronique &lt;br /&gt;
&lt;br /&gt;
3e scéance  17/03: Continuation du schéma &lt;br /&gt;
&lt;br /&gt;
4e scéance  24/03: Correction du schéma&lt;br /&gt;
&lt;br /&gt;
5e scéance  31/03: Fin de la réalisation du schéma &lt;br /&gt;
&lt;br /&gt;
7e scéance 28/04 : &lt;br /&gt;
&lt;br /&gt;
8e scéance 05/05 : Soudure (pas trop eu accès aux fers) &lt;br /&gt;
&lt;br /&gt;
9e scéance 12/05 : Soudure&lt;br /&gt;
&lt;br /&gt;
10e scéance 19/05: Correction de la soudure ( LED soudé à l&#039;envers)&lt;br /&gt;
&lt;br /&gt;
11e scéance 26/05 :test des LED + début de programmation  &lt;br /&gt;
&lt;br /&gt;
12e scéance (bonus)02/06: soudure final } programmation &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Eventuellement la vidéo brève du fonctionnement complet du programmateur : [[Média:2025-PSE-B3-PROG-final.mp4]].&lt;br /&gt;
&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Mon archive GIT pour le projet KiCAD et pour les programmes : [https://gitea.plil.fr/stazani/2025_PSE_B3_stazani_lkachour.git].&lt;br /&gt;
&lt;br /&gt;
Archive privée. Binôme comme administrateur. Boé et Redon comme administrateur.&lt;br /&gt;
&lt;br /&gt;
Ajouter un &amp;lt;code&amp;gt;.gitignore&amp;lt;/code&amp;gt; pour KiCAD et langage C.&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
&#039;&#039;&#039;Objectif :&#039;&#039;&#039; Réaliser un système embarqué capable de mesurer le niveau sonore à l&#039;aide d&#039;un microphone et d&#039;afficher visuellement l&#039;intensité du son à l&#039;aide de LEDs de couleurs (vertes, oranges, rouges).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Travail effectué ==&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Journal de bord&#039;&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;1&amp;lt;sup&amp;gt;ère&amp;lt;/sup&amp;gt; séance — 03/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé par chercher une idée de projet et voir ce qu’on pouvait faire comme système embarqué. On a aussi commencé à mettre en place le projet, avec l’organisation du Git et les premières idées pour la carte. &lt;br /&gt;
&lt;br /&gt;
On a commencé à réfléchir au schéma électronique, surtout sur les composants principaux, les LED et les broches qu’on allait utiliser.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;2&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 10/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé la réalisation du schéma électronique sur KiCad. &lt;br /&gt;
&lt;br /&gt;
On a placé les premiers composants et on a commencé à faire les connexions. Le but était surtout de poser les bases de la carte et de voir comment relier les différents éléments entre eux.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;3&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 17/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a continué le schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a avancé sur les connexions et on a vérifié que les broches utilisées étaient cohérentes avec ce qu’on voulait faire. On a aussi commencé à faire attention aux LED et à leur branchement, pour pouvoir les tester après.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;4&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 24/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a corrigé le schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a regardé les erreurs possibles dans KiCad, comme les connexions oubliées ou les signaux mal reliés. On a aussi corrigé certaines parties du schéma pour que la carte soit plus propre avant de passer à la suite.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;5&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 31/03&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a fini la réalisation du schéma électronique. &lt;br /&gt;
&lt;br /&gt;
On a fait les dernières corrections et vérifications pour avoir un schéma utilisable. À la fin de cette séance, la partie schéma était quasiment terminée et prête pour la partie matérielle.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;6&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Séance non renseignée.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;7&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 28/04&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a repris le projet et on a préparé la partie matérielle. &lt;br /&gt;
&lt;br /&gt;
On a vérifié la carte et les composants avant de commencer vraiment la soudure. Le but était de s’assurer qu’on pouvait assembler la carte correctement et qu’il ne manquait pas d’éléments importants.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;8&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 05/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé la soudure des composants sur la carte. &lt;br /&gt;
&lt;br /&gt;
On n’a pas eu beaucoup accès aux fers à souder donc on n’a pas pu avancer autant que prévu, mais on a quand même commencé l’assemblage. Cette séance nous a permis de passer du schéma KiCad à la carte réelle.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;9&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 12/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a continué la soudure sur la carte. &lt;br /&gt;
&lt;br /&gt;
On a soudé d’autres composants et on a essayé de faire attention au sens des composants, surtout les LED. On a aussi regardé les soudures pour éviter les faux contacts ou les courts-circuits.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;10&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 19/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a corrigé la soudure de la carte. &lt;br /&gt;
&lt;br /&gt;
On s’est rendu compte qu’une LED avait été soudée à l’envers, donc elle ne pouvait pas fonctionner correctement. On l’a donc dessoudée puis ressoudée dans le bon sens. Ça nous a permis de mieux comprendre l’importance de la polarité des LED.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;11&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance — 26/05&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a commencé les tests des LED et le début de la programmation. &lt;br /&gt;
&lt;br /&gt;
Le but était de vérifier si les LED s’allumaient correctement après la soudure. On a surtout travaillé sur la LED reliée à la broche 26. &lt;br /&gt;
&lt;br /&gt;
On a aussi commencé à faire un programme simple pour configurer la broche en sortie et faire clignoter la LED. Cette séance a permis de faire le lien entre la carte électronique et le programme en C.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size:1.2em; font-weight:bold; border-bottom:1px solid #a2a9b1; margin-top:1.5em; margin-bottom:0.5em; color:#202122;&amp;quot;&amp;gt;12&amp;lt;sup&amp;gt;e&amp;lt;/sup&amp;gt; séance bonus — 02/06&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On a terminé les dernières soudures de la carte et on a continué la programmation. &lt;br /&gt;
&lt;br /&gt;
On a fait les tests finaux pour vérifier que les LED fonctionnaient bien. Le programme permettait d’allumer et d’éteindre la LED avec un délai, pour voir si la broche 26 était bien commandée. &lt;br /&gt;
&lt;br /&gt;
Cette séance nous a permis de finaliser la partie matérielle et de valider les premiers tests du logiciel.&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&lt;br /&gt;
Eventuellement la vidéo brève du fonctionnement complet du programmateur : [[Média:2025-PSE-B3-systeme-final.mp4]].&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10847</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10847"/>
		<updated>2026-06-14T19:56:37Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Historique des Scéances */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Historique des scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;03/03 : soudure&amp;lt;/div&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;11/03 : fonctions test&amp;lt;/div&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/div&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;17/04 : minicom&amp;lt;/div&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/div&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/div&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/div&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;02/05 : finition du projet&amp;lt;/div&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Il se peut que certaines fonctions on été modifiée sur le git depuis la création de ce wiki. Notamment à propos de la gestion du temps ou de l&#039;utilisation de fonctions externes. Mais le principe de ces fonctions reste le même, c&#039;est ce qui est important d&#039;indiquer dans ce wiki.  &lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
=== Gestion du Temps (Timers AVR) ===&lt;br /&gt;
La gestion du temps est l&#039;un des facteur les plus important de ce projet. En effet, on doit avoir un timer différent pour chaque composants. L&#039;écran prend à lui tout seule un certains temps pour afficher des choses. Le capteur ultrason demande lui aussi un temps précis pour fonctioner... &lt;br /&gt;
&lt;br /&gt;
==== Le problème des délais bloquants ====&lt;br /&gt;
Initialement, les pauses (entre les mesures ou lors des changements de frames d&#039;animation sur l&#039;écran LCD) étaient gérées par la macro &amp;lt;code&amp;gt;_delay_ms()&amp;lt;/code&amp;gt;. Cette fonction est dite &amp;quot;bloquante&amp;quot; car elle monopolise intégralement le processeur (l&#039;ATmega32U4 tourne dans le vide en comptant des cycles d&#039;horloge). Pendant ce temps, le robot est complètement paralysé : il ne peut plus mesurer de distance, ni lire les données entrantes via USB, ni jouer de l&#039;audio de manière fluide.&lt;br /&gt;
&lt;br /&gt;
==== Le Chronomètre Système avec le Timer 0 ====&lt;br /&gt;
Pour pallier ce problème de paralysie, nous avons implémenté un chronomètre système absolu (SysTick) basé sur le &#039;&#039;&#039;Timer 0&#039;&#039;&#039; de l&#039;ATmega32U4, fonctionnant en tâche de fond de manière complètement transparente pour la boucle principale grâce aux interruptions matérielles. L&#039;objectif technique est de déclencher une interruption très exactement toutes les millisecondes (soit 1000 Hz).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Choix du Timer&#039;&#039;&#039; : &amp;lt;/li&amp;gt;&lt;br /&gt;
Le Timer 0 est un compteur sur 8 bits. Il est parfait pour gérer des interruptions régulières à basse résolution, ce qui permet de libérer les Timers 16 bits de la puce pour des tâches nécessitant une plus grande finesse (comme l&#039;audio dans notre cas).&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Mode de fonctionnement&#039;&#039;&#039; : &amp;lt;/li&amp;gt;&lt;br /&gt;
Nous configurons ce Timer en mode &#039;&#039;&#039;CTC&#039;&#039;&#039; (&#039;&#039;Clear Timer on Compare Match&#039;&#039;). Dans ce mode, le Timer s&#039;incrémente à partir de zéro et compare sa valeur en continu à la limite fixée dans le registre &amp;lt;code&amp;gt;OCR0A&amp;lt;/code&amp;gt;. Dès que la limite est atteinte, il déclenche une interruption matérielle et retourne automatiquement à 0 au cycle d&#039;horloge suivant, sans aucune intervention logicielle.&lt;br /&gt;
&lt;br /&gt;
[[File:Datasheet_Timer0_TCCR0A_WGM_Page_106.png|center|600px|Tableau de configuration du mode CTC]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Calcul de la fréquence et du Prescaler&#039;&#039;&#039; :&amp;lt;/li&amp;gt;&lt;br /&gt;
La fréquence d&#039;horloge de notre horloge externe est configurée sur 8 MHz. La formule mathématique dictée par la datasheet pour un Timer en mode CTC est la suivante :&lt;br /&gt;
f = \frac{f_{CPU}}{N \times (1 + OCR0A)}&lt;br /&gt;
Pour obtenir notre fréquence cible de 1000 Hz, nous divisons d&#039;abord l&#039;horloge système à l&#039;aide d&#039;un prédiviseur (Prescaler) N = 64. Le calcul de la valeur plafond de OCR0A devient alors une simple équation :&lt;br /&gt;
OCR0A = \frac{8000000}{64 \times 1000} - 1 = 124&lt;br /&gt;
&lt;br /&gt;
[[File:Datasheet_Timer0_TCCR0B_Prescaler_Page_X.png|center|600px|Tableau de sélection du Prescaler à 64]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
==== time.c ====&lt;br /&gt;
Fonction d&#039;initialisation expliqué ci-desuss :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
static volatile uint32_t temps_systeme = 0;&lt;br /&gt;
void temps_init(void) // TIMER 0&lt;br /&gt;
{&lt;br /&gt;
    // Mode CTC (Clear Timer on Compare Match)&lt;br /&gt;
    TCCR0A = (1 &amp;lt;&amp;lt; WGM01);&lt;br /&gt;
&lt;br /&gt;
    // Prescaler à 64 (Horloge à 8 MHz / 64 = 125 000 ticks par seconde)&lt;br /&gt;
    TCCR0B = (1 &amp;lt;&amp;lt; CS01) | (1 &amp;lt;&amp;lt; CS00);&lt;br /&gt;
&lt;br /&gt;
    // 125 000 ticks par seconde = 125 ticks par milliseconde.&lt;br /&gt;
    // On compte de 0 à 124 (soit 125 étapes)&lt;br /&gt;
    OCR0A = 124;&lt;br /&gt;
&lt;br /&gt;
    // Activer l&#039;interruption sur la comparaison A&lt;br /&gt;
    TIMSK0 |= (1 &amp;lt;&amp;lt; OCIE0A);&lt;br /&gt;
&lt;br /&gt;
    // Activer les interruptions globales du microcontrôleur&lt;br /&gt;
    sei();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Fonction d&#039;interruption qui permet d&#039;augmenter le compteur de temps :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Interuption déclenchée toutes les 1 milliseconde&lt;br /&gt;
ISR(TIMER0_COMPA_vect)&lt;br /&gt;
{&lt;br /&gt;
    millis_compteur++;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
La fonction qui est utilisée partout dans notre code qui utilise cette logique du &amp;lt;code&amp;gt;TIMER0&amp;lt;/code&amp;gt; qui permet de générer des compteurs de temps sans mettre en pause notre système :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
uint32_t get_millis(void)&lt;br /&gt;
{&lt;br /&gt;
    uint32_t temps_actuel;&lt;br /&gt;
&lt;br /&gt;
    // ATOMIC_BLOCK fige l&#039;alarme pendant 1 microseconde pour éviter qu&#039;elle ne modifie la variable pile au moment où on la lit&lt;br /&gt;
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)&lt;br /&gt;
    {&lt;br /&gt;
        temps_actuel = millis_compteur;&lt;br /&gt;
    }&lt;br /&gt;
    return temps_actuel;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Le mot-clé volatile&#039;&#039;&#039; : Il s&#039;agit d&#039;une instruction vitale donnée au compilateur GCC pour lui signifier que la variable temps_systeme peut être modifiée en arrière-plan à tout instant de manière &amp;quot;invisible&amp;quot; par le matériel (l&#039;ISR). Sans ce mot-clé, le flag d&#039;optimisation -Os la traiterait comme une constante et paralyserait la machine à états.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Le principe de ATOMIC_BLOCK&#039;&#039;&#039; : Le cœur de l&#039;ATmega32U4 étant sur 8 bits, il doit physiquement effectuer 4 opérations de lecture successives pour copier une valeur de 32 bits (la variable temps). Si l&#039;interruption matérielle du Timer 0 vient à s&#039;exécuter au beau milieu de ces opérations et modifie la variable source, la valeur finale retournée sera corrompue. Le bloc &#039;&#039;&#039;ATOMIC_BLOCK&#039;&#039;&#039; neutralise temporairement toutes les interruptions globales pendant la lecture pour garantir l&#039;intégrité absolue du temps.&lt;br /&gt;
&lt;br /&gt;
==== Répartition globale des Timers de l&#039;architecture ====&lt;br /&gt;
Grâce à la fonction get_millis(), toute l&#039;architecture de la boucle principale repose désormais sur des conditions de delta temporel fluides de type if (&amp;lt;code&amp;gt;get_millis() - temps_precedent &amp;gt; DELAI&amp;lt;/code&amp;gt;), rendant le multitâche possible. Pour avoir un audio précis on a séparé le timer réservé pour celui-ci du timer 0. Ce qui nous donne en résumé :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Timer 0 (8 bits)&#039;&#039;&#039; : Réservé exclusivement au Chronomètre Système (SysTick) tournant à 1 kHz.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Timer 3 (16 bits)&#039;&#039;&#039; : Réservé au Moteur Audio pour piloter le convertisseur DAC R-2R à une fréquence d&#039;échantillonnage très précise (8 kHz).&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;Note : plusieurs fonctions d&#039;interruptions sont commentées dans &amp;lt;code&amp;gt;time.c&amp;lt;/code&amp;gt; car on a fait des test pour vérifier le hardware (tests qui suggèrent un problème sur le hardware)&#039;&#039;&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;17/02 : initialisation&amp;lt;/div&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;03/03 : Début de la schématique &amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;10/03 : V1 schématique&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;31/03 : Correction de la V2&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;12/05 : Premières soudures&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;13/05 : Premières soudures&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;18/05 : Problème complation&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;21/05 : Codes écran + capteur&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;23/05 : Codes écran + capteur&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;25/05 : animations + interactions&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;10/06 : Code servos&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|1200px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600x|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|600px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|600px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Une soudure d&#039;ailleurs étroite du à la proximité des pattes sur la footprint.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_final.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10843</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10843"/>
		<updated>2026-06-14T19:51:09Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Historique des scéances */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Historique des scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;03/03 : soudure&amp;lt;/div&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/div&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;11/03 : fonctions test&amp;lt;/div&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/div&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;17/04 : minicom&amp;lt;/div&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/div&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/div&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/div&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;font-size: 1.2em; font-weight: bold; margin-top: 1em; margin-bottom: 0.5em;&amp;quot;&amp;gt;02/05 : finition du projet&amp;lt;/div&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Il se peut que certaines fonctions on été modifiée sur le git depuis la création de ce wiki. Notamment à propos de la gestion du temps ou de l&#039;utilisation de fonctions externes. Mais le principe de ces fonctions reste le même, c&#039;est ce qui est important d&#039;indiquer dans ce wiki.  &lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
=== Gestion du Temps (Timers AVR) ===&lt;br /&gt;
La gestion du temps est l&#039;un des facteur les plus important de ce projet. En effet, on doit avoir un timer différent pour chaque composants. L&#039;écran prend à lui tout seule un certains temps pour afficher des choses. Le capteur ultrason demande lui aussi un temps précis pour fonctioner... &lt;br /&gt;
&lt;br /&gt;
==== Le problème des délais bloquants ====&lt;br /&gt;
Initialement, les pauses (entre les mesures ou lors des changements de frames d&#039;animation sur l&#039;écran LCD) étaient gérées par la macro &amp;lt;code&amp;gt;_delay_ms()&amp;lt;/code&amp;gt;. Cette fonction est dite &amp;quot;bloquante&amp;quot; car elle monopolise intégralement le processeur (l&#039;ATmega32U4 tourne dans le vide en comptant des cycles d&#039;horloge). Pendant ce temps, le robot est complètement paralysé : il ne peut plus mesurer de distance, ni lire les données entrantes via USB, ni jouer de l&#039;audio de manière fluide.&lt;br /&gt;
&lt;br /&gt;
==== Le Chronomètre Système avec le Timer 0 ====&lt;br /&gt;
Pour pallier ce problème de paralysie, nous avons implémenté un chronomètre système absolu (SysTick) basé sur le &#039;&#039;&#039;Timer 0&#039;&#039;&#039; de l&#039;ATmega32U4, fonctionnant en tâche de fond de manière complètement transparente pour la boucle principale grâce aux interruptions matérielles. L&#039;objectif technique est de déclencher une interruption très exactement toutes les millisecondes (soit 1000 Hz).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Choix du Timer&#039;&#039;&#039; : &amp;lt;/li&amp;gt;&lt;br /&gt;
Le Timer 0 est un compteur sur 8 bits. Il est parfait pour gérer des interruptions régulières à basse résolution, ce qui permet de libérer les Timers 16 bits de la puce pour des tâches nécessitant une plus grande finesse (comme l&#039;audio dans notre cas).&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Mode de fonctionnement&#039;&#039;&#039; : &amp;lt;/li&amp;gt;&lt;br /&gt;
Nous configurons ce Timer en mode &#039;&#039;&#039;CTC&#039;&#039;&#039; (&#039;&#039;Clear Timer on Compare Match&#039;&#039;). Dans ce mode, le Timer s&#039;incrémente à partir de zéro et compare sa valeur en continu à la limite fixée dans le registre &amp;lt;code&amp;gt;OCR0A&amp;lt;/code&amp;gt;. Dès que la limite est atteinte, il déclenche une interruption matérielle et retourne automatiquement à 0 au cycle d&#039;horloge suivant, sans aucune intervention logicielle.&lt;br /&gt;
&lt;br /&gt;
[[File:Datasheet_Timer0_TCCR0A_WGM_Page_106.png|center|600px|Tableau de configuration du mode CTC]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Calcul de la fréquence et du Prescaler&#039;&#039;&#039; :&amp;lt;/li&amp;gt;&lt;br /&gt;
La fréquence d&#039;horloge de notre horloge externe est configurée sur 8 MHz. La formule mathématique dictée par la datasheet pour un Timer en mode CTC est la suivante :&lt;br /&gt;
f = \frac{f_{CPU}}{N \times (1 + OCR0A)}&lt;br /&gt;
Pour obtenir notre fréquence cible de 1000 Hz, nous divisons d&#039;abord l&#039;horloge système à l&#039;aide d&#039;un prédiviseur (Prescaler) N = 64. Le calcul de la valeur plafond de OCR0A devient alors une simple équation :&lt;br /&gt;
OCR0A = \frac{8000000}{64 \times 1000} - 1 = 124&lt;br /&gt;
&lt;br /&gt;
[[File:Datasheet_Timer0_TCCR0B_Prescaler_Page_X.png|center|600px|Tableau de sélection du Prescaler à 64]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
==== time.c ====&lt;br /&gt;
Fonction d&#039;initialisation expliqué ci-desuss :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
static volatile uint32_t temps_systeme = 0;&lt;br /&gt;
void temps_init(void) // TIMER 0&lt;br /&gt;
{&lt;br /&gt;
    // Mode CTC (Clear Timer on Compare Match)&lt;br /&gt;
    TCCR0A = (1 &amp;lt;&amp;lt; WGM01);&lt;br /&gt;
&lt;br /&gt;
    // Prescaler à 64 (Horloge à 8 MHz / 64 = 125 000 ticks par seconde)&lt;br /&gt;
    TCCR0B = (1 &amp;lt;&amp;lt; CS01) | (1 &amp;lt;&amp;lt; CS00);&lt;br /&gt;
&lt;br /&gt;
    // 125 000 ticks par seconde = 125 ticks par milliseconde.&lt;br /&gt;
    // On compte de 0 à 124 (soit 125 étapes)&lt;br /&gt;
    OCR0A = 124;&lt;br /&gt;
&lt;br /&gt;
    // Activer l&#039;interruption sur la comparaison A&lt;br /&gt;
    TIMSK0 |= (1 &amp;lt;&amp;lt; OCIE0A);&lt;br /&gt;
&lt;br /&gt;
    // Activer les interruptions globales du microcontrôleur&lt;br /&gt;
    sei();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Fonction d&#039;interruption qui permet d&#039;augmenter le compteur de temps :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Interuption déclenchée toutes les 1 milliseconde&lt;br /&gt;
ISR(TIMER0_COMPA_vect)&lt;br /&gt;
{&lt;br /&gt;
    millis_compteur++;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
La fonction qui est utilisée partout dans notre code qui utilise cette logique du &amp;lt;code&amp;gt;TIMER0&amp;lt;/code&amp;gt; qui permet de générer des compteurs de temps sans mettre en pause notre système :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
uint32_t get_millis(void)&lt;br /&gt;
{&lt;br /&gt;
    uint32_t temps_actuel;&lt;br /&gt;
&lt;br /&gt;
    // ATOMIC_BLOCK fige l&#039;alarme pendant 1 microseconde pour éviter qu&#039;elle ne modifie la variable pile au moment où on la lit&lt;br /&gt;
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)&lt;br /&gt;
    {&lt;br /&gt;
        temps_actuel = millis_compteur;&lt;br /&gt;
    }&lt;br /&gt;
    return temps_actuel;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Le mot-clé volatile&#039;&#039;&#039; : Il s&#039;agit d&#039;une instruction vitale donnée au compilateur GCC pour lui signifier que la variable temps_systeme peut être modifiée en arrière-plan à tout instant de manière &amp;quot;invisible&amp;quot; par le matériel (l&#039;ISR). Sans ce mot-clé, le flag d&#039;optimisation -Os la traiterait comme une constante et paralyserait la machine à états.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Le principe de ATOMIC_BLOCK&#039;&#039;&#039; : Le cœur de l&#039;ATmega32U4 étant sur 8 bits, il doit physiquement effectuer 4 opérations de lecture successives pour copier une valeur de 32 bits (la variable temps). Si l&#039;interruption matérielle du Timer 0 vient à s&#039;exécuter au beau milieu de ces opérations et modifie la variable source, la valeur finale retournée sera corrompue. Le bloc &#039;&#039;&#039;ATOMIC_BLOCK&#039;&#039;&#039; neutralise temporairement toutes les interruptions globales pendant la lecture pour garantir l&#039;intégrité absolue du temps.&lt;br /&gt;
&lt;br /&gt;
==== Répartition globale des Timers de l&#039;architecture ====&lt;br /&gt;
Grâce à la fonction get_millis(), toute l&#039;architecture de la boucle principale repose désormais sur des conditions de delta temporel fluides de type if (&amp;lt;code&amp;gt;get_millis() - temps_precedent &amp;gt; DELAI&amp;lt;/code&amp;gt;), rendant le multitâche possible. Pour avoir un audio précis on a séparé le timer réservé pour celui-ci du timer 0. Ce qui nous donne en résumé :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Timer 0 (8 bits)&#039;&#039;&#039; : Réservé exclusivement au Chronomètre Système (SysTick) tournant à 1 kHz.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Timer 3 (16 bits)&#039;&#039;&#039; : Réservé au Moteur Audio pour piloter le convertisseur DAC R-2R à une fréquence d&#039;échantillonnage très précise (8 kHz).&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|1200px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600x|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|600px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|600px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Une soudure d&#039;ailleurs étroite du à la proximité des pattes sur la footprint.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_final.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10841</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10841"/>
		<updated>2026-06-14T19:46:22Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Bilan */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Historique des scéances ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Il se peut que certaines fonctions on été modifiée sur le git depuis la création de ce wiki. Notamment à propos de la gestion du temps ou de l&#039;utilisation de fonctions externes. Mais le principe de ces fonctions reste le même, c&#039;est ce qui est important d&#039;indiquer dans ce wiki.  &lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
=== Gestion du Temps (Timers AVR) ===&lt;br /&gt;
La gestion du temps est l&#039;un des facteur les plus important de ce projet. En effet, on doit avoir un timer différent pour chaque composants. L&#039;écran prend à lui tout seule un certains temps pour afficher des choses. Le capteur ultrason demande lui aussi un temps précis pour fonctioner... &lt;br /&gt;
&lt;br /&gt;
==== Le problème des délais bloquants ====&lt;br /&gt;
Initialement, les pauses (entre les mesures ou lors des changements de frames d&#039;animation sur l&#039;écran LCD) étaient gérées par la macro &amp;lt;code&amp;gt;_delay_ms()&amp;lt;/code&amp;gt;. Cette fonction est dite &amp;quot;bloquante&amp;quot; car elle monopolise intégralement le processeur (l&#039;ATmega32U4 tourne dans le vide en comptant des cycles d&#039;horloge). Pendant ce temps, le robot est complètement paralysé : il ne peut plus mesurer de distance, ni lire les données entrantes via USB, ni jouer de l&#039;audio de manière fluide.&lt;br /&gt;
&lt;br /&gt;
==== Le Chronomètre Système avec le Timer 0 ====&lt;br /&gt;
Pour pallier ce problème de paralysie, nous avons implémenté un chronomètre système absolu (SysTick) basé sur le &#039;&#039;&#039;Timer 0&#039;&#039;&#039; de l&#039;ATmega32U4, fonctionnant en tâche de fond de manière complètement transparente pour la boucle principale grâce aux interruptions matérielles. L&#039;objectif technique est de déclencher une interruption très exactement toutes les millisecondes (soit 1000 Hz).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Choix du Timer&#039;&#039;&#039; : &amp;lt;/li&amp;gt;&lt;br /&gt;
Le Timer 0 est un compteur sur 8 bits. Il est parfait pour gérer des interruptions régulières à basse résolution, ce qui permet de libérer les Timers 16 bits de la puce pour des tâches nécessitant une plus grande finesse (comme l&#039;audio dans notre cas).&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Mode de fonctionnement&#039;&#039;&#039; : &amp;lt;/li&amp;gt;&lt;br /&gt;
Nous configurons ce Timer en mode &#039;&#039;&#039;CTC&#039;&#039;&#039; (&#039;&#039;Clear Timer on Compare Match&#039;&#039;). Dans ce mode, le Timer s&#039;incrémente à partir de zéro et compare sa valeur en continu à la limite fixée dans le registre &amp;lt;code&amp;gt;OCR0A&amp;lt;/code&amp;gt;. Dès que la limite est atteinte, il déclenche une interruption matérielle et retourne automatiquement à 0 au cycle d&#039;horloge suivant, sans aucune intervention logicielle.&lt;br /&gt;
&lt;br /&gt;
[[File:Datasheet_Timer0_TCCR0A_WGM_Page_106.png|center|600px|Tableau de configuration du mode CTC]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Calcul de la fréquence et du Prescaler&#039;&#039;&#039; :&amp;lt;/li&amp;gt;&lt;br /&gt;
La fréquence d&#039;horloge de notre horloge externe est configurée sur 8 MHz. La formule mathématique dictée par la datasheet pour un Timer en mode CTC est la suivante :&lt;br /&gt;
f = \frac{f_{CPU}}{N \times (1 + OCR0A)}&lt;br /&gt;
Pour obtenir notre fréquence cible de 1000 Hz, nous divisons d&#039;abord l&#039;horloge système à l&#039;aide d&#039;un prédiviseur (Prescaler) N = 64. Le calcul de la valeur plafond de OCR0A devient alors une simple équation :&lt;br /&gt;
OCR0A = \frac{8000000}{64 \times 1000} - 1 = 124&lt;br /&gt;
&lt;br /&gt;
[[File:Datasheet_Timer0_TCCR0B_Prescaler_Page_X.png|center|600px|Tableau de sélection du Prescaler à 64]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
==== time.c ====&lt;br /&gt;
Fonction d&#039;initialisation expliqué ci-desuss :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
static volatile uint32_t temps_systeme = 0;&lt;br /&gt;
void temps_init(void) // TIMER 0&lt;br /&gt;
{&lt;br /&gt;
    // Mode CTC (Clear Timer on Compare Match)&lt;br /&gt;
    TCCR0A = (1 &amp;lt;&amp;lt; WGM01);&lt;br /&gt;
&lt;br /&gt;
    // Prescaler à 64 (Horloge à 8 MHz / 64 = 125 000 ticks par seconde)&lt;br /&gt;
    TCCR0B = (1 &amp;lt;&amp;lt; CS01) | (1 &amp;lt;&amp;lt; CS00);&lt;br /&gt;
&lt;br /&gt;
    // 125 000 ticks par seconde = 125 ticks par milliseconde.&lt;br /&gt;
    // On compte de 0 à 124 (soit 125 étapes)&lt;br /&gt;
    OCR0A = 124;&lt;br /&gt;
&lt;br /&gt;
    // Activer l&#039;interruption sur la comparaison A&lt;br /&gt;
    TIMSK0 |= (1 &amp;lt;&amp;lt; OCIE0A);&lt;br /&gt;
&lt;br /&gt;
    // Activer les interruptions globales du microcontrôleur&lt;br /&gt;
    sei();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Fonction d&#039;interruption qui permet d&#039;augmenter le compteur de temps :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Interuption déclenchée toutes les 1 milliseconde&lt;br /&gt;
ISR(TIMER0_COMPA_vect)&lt;br /&gt;
{&lt;br /&gt;
    millis_compteur++;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
La fonction qui est utilisée partout dans notre code qui utilise cette logique du &amp;lt;code&amp;gt;TIMER0&amp;lt;/code&amp;gt; qui permet de générer des compteurs de temps sans mettre en pause notre système :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
uint32_t get_millis(void)&lt;br /&gt;
{&lt;br /&gt;
    uint32_t temps_actuel;&lt;br /&gt;
&lt;br /&gt;
    // ATOMIC_BLOCK fige l&#039;alarme pendant 1 microseconde pour éviter qu&#039;elle ne modifie la variable pile au moment où on la lit&lt;br /&gt;
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)&lt;br /&gt;
    {&lt;br /&gt;
        temps_actuel = millis_compteur;&lt;br /&gt;
    }&lt;br /&gt;
    return temps_actuel;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Le mot-clé volatile&#039;&#039;&#039; : Il s&#039;agit d&#039;une instruction vitale donnée au compilateur GCC pour lui signifier que la variable temps_systeme peut être modifiée en arrière-plan à tout instant de manière &amp;quot;invisible&amp;quot; par le matériel (l&#039;ISR). Sans ce mot-clé, le flag d&#039;optimisation -Os la traiterait comme une constante et paralyserait la machine à états.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Le principe de ATOMIC_BLOCK&#039;&#039;&#039; : Le cœur de l&#039;ATmega32U4 étant sur 8 bits, il doit physiquement effectuer 4 opérations de lecture successives pour copier une valeur de 32 bits (la variable temps). Si l&#039;interruption matérielle du Timer 0 vient à s&#039;exécuter au beau milieu de ces opérations et modifie la variable source, la valeur finale retournée sera corrompue. Le bloc &#039;&#039;&#039;ATOMIC_BLOCK&#039;&#039;&#039; neutralise temporairement toutes les interruptions globales pendant la lecture pour garantir l&#039;intégrité absolue du temps.&lt;br /&gt;
&lt;br /&gt;
==== Répartition globale des Timers de l&#039;architecture ====&lt;br /&gt;
Grâce à la fonction get_millis(), toute l&#039;architecture de la boucle principale repose désormais sur des conditions de delta temporel fluides de type if (&amp;lt;code&amp;gt;get_millis() - temps_precedent &amp;gt; DELAI&amp;lt;/code&amp;gt;), rendant le multitâche possible. Pour avoir un audio précis on a séparé le timer réservé pour celui-ci du timer 0. Ce qui nous donne en résumé :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Timer 0 (8 bits)&#039;&#039;&#039; : Réservé exclusivement au Chronomètre Système (SysTick) tournant à 1 kHz.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Timer 3 (16 bits)&#039;&#039;&#039; : Réservé au Moteur Audio pour piloter le convertisseur DAC R-2R à une fréquence d&#039;échantillonnage très précise (8 kHz).&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|1200px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600x|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|600px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|600px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Une soudure d&#039;ailleurs étroite du à la proximité des pattes sur la footprint.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_final.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10839</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10839"/>
		<updated>2026-06-14T19:33:08Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|1200px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600x|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|600px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|600px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Une soudure d&#039;ailleurs étroite du à la proximité des pattes sur la footprint.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_final.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10838</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10838"/>
		<updated>2026-06-14T19:32:12Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|1200px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600x|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|600px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|600px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Une soudure d&#039;ailleurs étroite du à la proximités des pattes sur la footprint.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_final.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10837</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10837"/>
		<updated>2026-06-14T19:29:54Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|1200px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600x|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|600px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|600px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_final.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10836</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10836"/>
		<updated>2026-06-14T19:28:03Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|1200px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|900px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|600px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|600px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_final.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10835</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10835"/>
		<updated>2026-06-14T19:26:59Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|900px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|900px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|600px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|600px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_final.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10834</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10834"/>
		<updated>2026-06-14T19:25:09Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|600px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|600px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|600px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_final.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Booster_final.jpeg&amp;diff=10831</id>
		<title>Fichier:Booster final.jpeg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Booster_final.jpeg&amp;diff=10831"/>
		<updated>2026-06-14T19:22:11Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10830</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10830"/>
		<updated>2026-06-14T19:10:36Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|400px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|400px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|400px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|400px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_final.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10828</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10828"/>
		<updated>2026-06-14T19:09:40Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|400px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|400px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|400px|Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|400px|Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_extended.jpeg|center|sans_cadre|400px]]&amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Booster_extended_reinforced.jpeg&amp;diff=10826</id>
		<title>Fichier:Booster extended reinforced.jpeg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Booster_extended_reinforced.jpeg&amp;diff=10826"/>
		<updated>2026-06-14T19:03:22Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10823</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10823"/>
		<updated>2026-06-14T19:01:11Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|900px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|710px| Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|710px|  Booster de tension étendu et renforcé]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_extended.jpeg|right|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039; Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10822</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10822"/>
		<updated>2026-06-14T18:57:52Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|900px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|710px| Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended_reinforced.jpeg|thumb|right|710px|  Booster de tension étendu et renforcé]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_extended.jpeg|right|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039; Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Booster_extended.jpeg&amp;diff=10821</id>
		<title>Fichier:Booster extended.jpeg</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Booster_extended.jpeg&amp;diff=10821"/>
		<updated>2026-06-14T18:56:22Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10820</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10820"/>
		<updated>2026-06-14T18:52:07Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|900px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|left|710px| Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended.jpeg|thumb|right|710px|  Booster de tension étendu et renforcé]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_extended.jpeg|right|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039; Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10815</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10815"/>
		<updated>2026-06-14T18:44:04Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|900px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.png|thumb|left|710px| Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended.png|thumb|right|710px|  Booster de tension étendu et renforcé]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_extended.png|right|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039; Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10812</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10812"/>
		<updated>2026-06-14T18:41:03Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|900px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|600px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.png|thumb|left|710px| Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended.png|thumb|right|710px|  Booster de tension étendu et renforcé]]&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_extended.png|right|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039; Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10810</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10810"/>
		<updated>2026-06-14T18:39:18Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
On retrouve dans cette sections les détails du code pour notre premier système embarqué. Tout n&#039;est pas indiqué car cela aurait trop de contenu pas forcément intéressant à lire.&lt;br /&gt;
Le README de notre git indique l&#039;utilisation de notre programme ainsi qu&#039;un résumé très bref de chaque fichiers C.&lt;br /&gt;
La section &amp;lt;code&amp;gt;OBJECTIFS&amp;lt;/code&amp;gt; résume ce que nous avons réussi à faire et à ne pas faire.&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|900px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|710px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.png|thumb|left|710px| Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended.png|thumb|right|710px|  Booster de tension étendu et renforcé]]&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_extended.png|right|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039; Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Booster_footprint.png&amp;diff=10801</id>
		<title>Fichier:Booster footprint.png</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=Fichier:Booster_footprint.png&amp;diff=10801"/>
		<updated>2026-06-14T17:06:02Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
	<entry>
		<id>https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10800</id>
		<title>SE3Groupe2025-2</title>
		<link rel="alternate" type="text/html" href="https://projets-se.plil.fr/mediawiki/index.php?title=SE3Groupe2025-2&amp;diff=10800"/>
		<updated>2026-06-14T17:00:42Z</updated>

		<summary type="html">&lt;p&gt;Jramesh : /* Booster de tension */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;br /&gt;
= Programmation des systèmes embarqués =&lt;br /&gt;
&lt;br /&gt;
Fabrication et programmation d&#039;un programmeur AVR. But : programmer d&#039;autres µP via le protocole ISP.&lt;br /&gt;
&lt;br /&gt;
== Carte électronique ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[file:2025-PSE-2-Prog.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-02-PROG-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-PROG-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
{| style=&amp;quot;margin: auto;&amp;quot;&lt;br /&gt;
| [[File:Schema final 3D.png|thumb|500px|3d]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-front.jpg|thumb|400px|Front]]&lt;br /&gt;
| [[File:2025 PSE-02-PROG-carte-soudée-back.jpg|thumb|400px|Back]]&lt;br /&gt;
|}&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
Les tests finaux on été réalisé sur une arduino UNO [[File : PSE2_montage_isp.png|center|400x400px|Montage]]&lt;br /&gt;
===Teste de la carte===&lt;br /&gt;
Pour tester notre carte on a fait des codes simples.&lt;br /&gt;
====led_blink====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
// Clignote les 3 LEDS&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;
#define BLINK_DELAY 50 // en milli secondes&lt;br /&gt;
&lt;br /&gt;
// PB 5, 6, 7 correspond respectivement aux leds 1 , 2 , 3&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
  // configurer les led en sortie :&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 5); // PORTB 5e bit pour la LED1&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 6); // PORTB 6e bit pour la LED2&lt;br /&gt;
  DDRB |= (1 &amp;lt;&amp;lt; 7); // PORTB 7e bit pour la LED3&lt;br /&gt;
&lt;br /&gt;
  for (int i = 0; i &amp;lt; 50; i++)&lt;br /&gt;
  {&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 5); // OR&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
&lt;br /&gt;
    // led off&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 5); // AND + NOT&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    PORTB &amp;amp;= ~(1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
  }&lt;br /&gt;
  return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-blink.mp4|Blink]]&lt;br /&gt;
&lt;br /&gt;
====boutons====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&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;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
#define L5 0b11011111&lt;br /&gt;
#define L6 0b10111111&lt;br /&gt;
#define L7 0b01111111&lt;br /&gt;
&lt;br /&gt;
void config()&lt;br /&gt;
{&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
&lt;br /&gt;
    DDRC &amp;amp;= 0x00;&lt;br /&gt;
&lt;br /&gt;
    // Activation des résistances de Pull-Up internes sur le port C&lt;br /&gt;
    PORTC |= (b6 | b7);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int lire_bouton(int bouton)&lt;br /&gt;
{&lt;br /&gt;
    return (PINC &amp;amp; bouton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void ecrire_LED(int LED, int etat)&lt;br /&gt;
{&lt;br /&gt;
    switch (etat)&lt;br /&gt;
    {&lt;br /&gt;
    case 0:&lt;br /&gt;
        PORTB &amp;amp;= LED; // Applique le masque avec le 0 pour éteindre&lt;br /&gt;
        break;&lt;br /&gt;
    case 1:&lt;br /&gt;
        PORTB |= ~LED; // Inverse le masque pour avoir un 1 et allumer&lt;br /&gt;
        break;&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main()&lt;br /&gt;
{&lt;br /&gt;
    config();&lt;br /&gt;
&lt;br /&gt;
    while (1)&lt;br /&gt;
    {&lt;br /&gt;
        if (lire_bouton(b6) &amp;amp;&amp;amp; lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L7, 1);&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton(b7))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L5, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else if (lire_bouton((b6)))&lt;br /&gt;
        {&lt;br /&gt;
            ecrire_LED(L6, 1);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            // On éteint tout si aucun bouton n&#039;est pressé&lt;br /&gt;
            ecrire_LED(L6, 0);&lt;br /&gt;
            ecrire_LED(L5, 0);&lt;br /&gt;
            ecrire_LED(L7, 0);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return 0;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:2025-PSE-02-PROG-video-boutons.mp4|Boutons]]&lt;br /&gt;
&lt;br /&gt;
===LUFA===&lt;br /&gt;
Pour injecter un nouveau code sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase --force                                                       &lt;br /&gt;
dfu-programmer atmega16u2 flash --suppress-bootloader-mem file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Pour injecter le même code mais modifié sur la carte(être sudo):&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
dfu-programmer atmega16u2 erase                                                        &lt;br /&gt;
dfu-programmer atmega16u2 flash file.hex&lt;br /&gt;
dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Connexion avec minicom====&lt;br /&gt;
On a récupéré le dossier LUFA depuis le wiki du cours. Puis on a copié le fichier &amp;lt;code&amp;gt;VirtualSerial&amp;lt;/code&amp;gt; situé dans &amp;lt;code&amp;gt;lufa-LUFA-210130-NSI/Demos/Device/ClassDriver/VirtualSerial&amp;lt;/code&amp;gt;.&lt;br /&gt;
L&#039;objectif ici est de communiquer grâce à la LUFA en USB sur minicom.&lt;br /&gt;
Dans &amp;lt;code&amp;gt;VirtualSerial.c&amp;lt;/code&amp;gt; on modifie la fonction &amp;lt;code&amp;gt;CheckJoystickMovement(void)&amp;lt;/code&amp;gt; par la fonction :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define b7 0b10000000&lt;br /&gt;
#define b6 0b01000000&lt;br /&gt;
&lt;br /&gt;
int Button_Status(int boutton)&lt;br /&gt;
{&lt;br /&gt;
	return (PINC &amp;amp; boutton) == 0;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void CheckButtons(void)&lt;br /&gt;
{&lt;br /&gt;
	char *ReportString = NULL;&lt;br /&gt;
	static bool ActionSent = false;&lt;br /&gt;
&lt;br /&gt;
	if (Button_Status(b6) &amp;amp;&amp;amp; Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;both pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b6))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b6 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
	else if (Button_Status(b7))&lt;br /&gt;
	{&lt;br /&gt;
		ReportString = &amp;quot;b7 pressed\r\n&amp;quot;;&lt;br /&gt;
		_delay_ms(250);&lt;br /&gt;
		ActionSent = false;&lt;br /&gt;
	}&lt;br /&gt;
&lt;br /&gt;
	if ((ReportString != NULL) &amp;amp;&amp;amp; (ActionSent == false))&lt;br /&gt;
	{&lt;br /&gt;
		ActionSent = true;&lt;br /&gt;
&lt;br /&gt;
		/* Write the string to the virtual COM port via the created character stream */&lt;br /&gt;
		fputs(ReportString, &amp;amp;USBSerialStream);&lt;br /&gt;
&lt;br /&gt;
		/* Alternatively, without the stream: */&lt;br /&gt;
		// CDC_Device_SendString(&amp;amp;VirtualSerial_CDC_Interface, ReportString);&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
On change &amp;lt;code&amp;gt;VirtualSerial.h&amp;lt;/code&amp;gt; en conséquence.&lt;br /&gt;
On modifie la &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; adapté à notre µP :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
MCU          = atmega16u2&lt;br /&gt;
ARCH         = AVR8&lt;br /&gt;
BOARD        = NONE&lt;br /&gt;
F_CPU        = 16000000&lt;br /&gt;
F_USB        = $(F_CPU)&lt;br /&gt;
OPTIMIZATION = s&lt;br /&gt;
TARGET       = VirtualSerial&lt;br /&gt;
SRC          = $(TARGET).c Descriptors.c $(LUFA_SRC_USB) $(LUFA_SRC_USBCLASS)&lt;br /&gt;
LUFA_PATH    = ../../LUFA&lt;br /&gt;
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/&lt;br /&gt;
LD_FLAGS     =&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On compile le programme :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On injecte le code sur la carte: &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo dfu-programmer atmega16u2 erase&lt;br /&gt;
sudo dfu-programmer atmega16u2 flash&lt;br /&gt;
sudo dfu-programmer atmega16u2 reset&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
Erasing flash...  Success&lt;br /&gt;
Checking memory from 0x0 to 0x2FFF...  Empty.&lt;br /&gt;
Checking memory from 0x0 to 0xEFF...  Empty.&lt;br /&gt;
0%                            100%  Programming 0xF00 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
0%                            100%  Reading 0x3000 bytes...&lt;br /&gt;
[&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;]  Success&lt;br /&gt;
Validating...  Success&lt;br /&gt;
0xF00 bytes written into 0x3000 bytes memory (31.25%).&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
et on observe bien un changement de nom de notre carte :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
lsusb                                                                                               &lt;br /&gt;
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub&lt;br /&gt;
Bus 001 Device 002: ID 0408:a061 Quanta Computer, Inc. HD User Facing&lt;br /&gt;
Bus 001 Device 003: ID 8087:0026 Intel Corp. AX201 Bluetooth&lt;br /&gt;
Bus 001 Device 005: ID 046d:0aba Logitech, Inc. PRO X Wireless Gaming Headset&lt;br /&gt;
Bus 001 Device 012: ID 046d:c08b Logitech, Inc. G502 SE HERO Gaming Mouse&lt;br /&gt;
Bus 001 Device 016: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Appli&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ensuite on configure &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt; via : &amp;lt;code&amp;gt;minicom -os&amp;lt;/code&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;configuration minicom&#039;&#039;&#039; :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Serial port setup&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;A&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;/dev/ttyACM0&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;E&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;C&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;F&amp;lt;/code&amp;gt; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;quot;Save setup as dfl&amp;quot; -&amp;gt; &amp;lt;code&amp;gt;ENTRER&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;Echape&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;Exit&amp;lt;/code&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
Puis on lance minicom via (être en sudo) &amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;minicom&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
Pour retéléverser un programme sur la carte, il faut la repasser en DFU. Pour cela il suffit d&#039;appuyer sur le bouton &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Resultat&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_minicom.mp4]]&lt;br /&gt;
&lt;br /&gt;
====Gestion personnalisée des Endpoints====&lt;br /&gt;
=====Configuration IN et OUT=====&lt;br /&gt;
L&#039;objectif est de s&#039;affranchir de la classe CDC pour gérer directement les points d&#039;accès (Endpoints). On définit une interface avec un point d&#039;accès OUT (pour contrôler les LEDs depuis le PC) et un point d&#039;accès IN (pour envoyer l&#039;état de la carte au PC).&lt;br /&gt;
&lt;br /&gt;
On modifie &amp;lt;code&amp;gt;Descriptors.h&amp;lt;/code&amp;gt; pour définir les adresses :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
/* Adresses des points d&#039;accès */&lt;br /&gt;
#define LED_OUT_EPADDR (ENDPOINT_DIR_OUT | 1) // Endpoint 1 OUT&lt;br /&gt;
#define DATA_IN_EPADDR (ENDPOINT_DIR_IN | 2)  // Endpoint 2 IN&lt;br /&gt;
/* Taille des paquets*/&lt;br /&gt;
#define LED_EPSIZE 8&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Dans &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, on remplace la gestion CDC par la configuration manuelle des points d&#039;accès lors de l&#039;énumération :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void EVENT_USB_Device_ConfigurationChanged(void)&lt;br /&gt;
{&lt;br /&gt;
	// Configuration du point d&#039;accès pour recevoir les ordres (LEDs)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(LED_OUT_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
	// Configuration du point d&#039;accès pour envoyer les données (Boutons/ISP)&lt;br /&gt;
	Endpoint_ConfigureEndpoint(DATA_IN_EPADDR, EP_TYPE_INTERRUPT, LED_EPSIZE, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données OUT=====&lt;br /&gt;
Pour piloter les LEDs (même si elles ne sont pas encore soudées, le code cible le &amp;lt;code&amp;gt;PORTB&amp;lt;/code&amp;gt;), on crée une fonction de traitement:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessLEDControl(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(LED_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			uint8_t LEDMask = Endpoint_Read_8();&lt;br /&gt;
			// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
			PORTB = LEDMask;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}Atmel-0943-In-System-Programming_ApplicationNote_AVR910&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Traitement des données IN=====&lt;br /&gt;
On récupère l&#039;état des boutons dans le &amp;lt;code&amp;gt;PINC&amp;lt;/code&amp;gt; :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ButtonsStatus(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		Endpoint_Write_8(PINC &amp;amp; 0xC0); //pour activer les résistances de pull up sur b6 et b7.&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Modification du Makefile=====&lt;br /&gt;
On retire les sources de la classe CDC (&amp;lt;code&amp;gt;LUFA_SRC_USBCLASS&amp;lt;/code&amp;gt;) car nous utilisons désormais les fonctions &amp;quot;Low Level&amp;quot; de la LUFA.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;Makefile&amp;quot;&amp;gt;&lt;br /&gt;
SRC = $(TARGET).c Descriptors.c $(LUFA_SRC_USB)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Programme PC avec libusb ===&lt;br /&gt;
Maintenant que la carte est configurée avec des Endpoints bruts (IN et OUT), nous devons écrire un programme C fonctionnant sous Linux pour communiquer avec elle. L&#039;outil standard pour cela est la bibliothèque &amp;lt;code&amp;gt;libusb-1.0&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
==== Code de test IN/OUT (main_pc.c) ====&lt;br /&gt;
Ce programme a pour but de valider la liaison USB bas niveau. Il va :&lt;br /&gt;
&lt;br /&gt;
Ouvrir la communication avec le périphérique (VID/PID).&lt;br /&gt;
Réclamer l&#039;interface.&lt;br /&gt;
Envoyer un ordre &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt; pour allumer les broches des LEDs (PORTB).&lt;br /&gt;
Lire un état &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt; pour récupérer l&#039;état des boutons (PORTC).&lt;br /&gt;
&lt;br /&gt;
=====Ouvrir la communication avec le périphérique=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
libusb_device_handle *init_usb(void)&lt;br /&gt;
{&lt;br /&gt;
    libusb_device_handle *dev_handle = NULL;&lt;br /&gt;
&lt;br /&gt;
    if (libusb_init(NULL) &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur d&#039;initialisation de libusb\n&amp;quot;);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    dev_handle = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, PRODUCT_ID);&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Impossible d&#039;ouvrir le périphérique (03EB:2044). Avez-vous utilisé sudo ?\n&amp;quot;);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return NULL;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    if (libusb_kernel_driver_active(dev_handle, 0) == 1)&lt;br /&gt;
    {&lt;br /&gt;
        libusb_detach_kernel_driver(dev_handle, 0);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    return dev_handle;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Réclamer l&#039;interface=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int reclamer_interface(libusb_device_handle *dev_handle)&lt;br /&gt;
{&lt;br /&gt;
    int r = libusb_claim_interface(dev_handle, 0);&lt;br /&gt;
    if (r &amp;lt; 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de réclamation de l&#039;interface : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
        libusb_close(dev_handle);&lt;br /&gt;
        libusb_exit(NULL);&lt;br /&gt;
        return -1;&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;
=====Configuration LED en OUT=====&lt;br /&gt;
On veut allumer les LEDS avec les touches du clavier en LIVE. Pour cela on utilise la bibliothèque &amp;lt;code&amp;gt;termios.h&amp;lt;/code&amp;gt; utilisé dans la fonction &amp;lt;code&amp;gt;kbhit()&amp;lt;/code&amp;gt;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 printf(&amp;quot;\n=== MODE LIVE ACTIVÉ ===\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;Touches :\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [A] : Basculer LED 1 (PB5)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Z] : Basculer LED 2 (PB6)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [E] : Basculer LED 3 (PB7)\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot; [Q] : Quitter\n&amp;quot;);&lt;br /&gt;
    printf(&amp;quot;========================\n\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
    unsigned char data_out = 0x00;&lt;br /&gt;
    unsigned char last_data_in = 0xFF; // Pour mémoriser l&#039;ancien état des boutons&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    int running = 1;&lt;br /&gt;
&lt;br /&gt;
    while (running)&lt;br /&gt;
    {&lt;br /&gt;
        if (kbhit())&lt;br /&gt;
        {&lt;br /&gt;
            char c = getchar();&lt;br /&gt;
            int send_update = 0;&lt;br /&gt;
&lt;br /&gt;
            switch (c)&lt;br /&gt;
            {&lt;br /&gt;
            case &#039;a&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 5);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB5&lt;br /&gt;
            case &#039;z&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 6);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB6&lt;br /&gt;
            case &#039;e&#039;:&lt;br /&gt;
                data_out ^= (1 &amp;lt;&amp;lt; 7);&lt;br /&gt;
                send_update = 1;&lt;br /&gt;
                break; // Bascule PB7&lt;br /&gt;
            case &#039;q&#039;:&lt;br /&gt;
                running = 0;&lt;br /&gt;
                break;&lt;br /&gt;
            }&lt;br /&gt;
&lt;br /&gt;
            if (send_update)&lt;br /&gt;
            {&lt;br /&gt;
                // Envoi de la nouvelle configuration OUT&lt;br /&gt;
                int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
                if (r == 0)&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
                }&lt;br /&gt;
                else&lt;br /&gt;
                {&lt;br /&gt;
                    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
                }&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
=====Configuration boutons en IN=====&lt;br /&gt;
Ce bout de code permet d&#039;afficher l&#039;état des boutons.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
 unsigned char data_in = 0;&lt;br /&gt;
        // On met un timeout très court (10ms) pour ne pas bloquer la boucle&lt;br /&gt;
        int r = libusb_interrupt_transfer(dev_handle, EP_IN, &amp;amp;data_in, 1, &amp;amp;actual_length, 10);&lt;br /&gt;
&lt;br /&gt;
        if (r == 0 &amp;amp;&amp;amp; actual_length == 1)&lt;br /&gt;
        {&lt;br /&gt;
            // On n&#039;affiche que si l&#039;état des boutons a changé (pour éviter de spammer la console)&lt;br /&gt;
            if (data_in != last_data_in)&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;[CARTE] État PORTC : 0x%02X -&amp;gt; &amp;quot;, data_in);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B6 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) == 0)&lt;br /&gt;
                    printf(&amp;quot;B7 pressé ! &amp;quot;);&lt;br /&gt;
                if ((data_in &amp;amp; (1 &amp;lt;&amp;lt; 6)) != 0 &amp;amp;&amp;amp; (data_in &amp;amp; (1 &amp;lt;&amp;lt; 7)) != 0)&lt;br /&gt;
                    printf(&amp;quot;Relâchés.&amp;quot;);&lt;br /&gt;
                printf(&amp;quot;\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
                last_data_in = data_in;&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
        // Petite pause pour ne pas surcharger le processeur du PC (10 millisecondes)&lt;br /&gt;
        usleep(10000);&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
====Résultat====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./main_pc  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Terminal&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== MODE LIVE ACTIVÉ ===&lt;br /&gt;
Touches :&lt;br /&gt;
 [A] : Basculer LED 1 (PB5)&lt;br /&gt;
 [Z] : Basculer LED 2 (PB6)&lt;br /&gt;
 [E] : Basculer LED 3 (PB7)&lt;br /&gt;
 [Q] : Quitter&lt;br /&gt;
========================&lt;br /&gt;
&lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x80 -&amp;gt; B6 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
[CARTE] État PORTC : 0x00 -&amp;gt; B6 pressé ! B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0x40 -&amp;gt; B7 pressé ! &lt;br /&gt;
[CARTE] État PORTC : 0xC0 -&amp;gt; Relâchés.&lt;br /&gt;
a[PC] Ordre envoyé : 0x20&lt;br /&gt;
z[PC] Ordre envoyé : 0x60&lt;br /&gt;
e[PC] Ordre envoyé : 0xE0&lt;br /&gt;
q&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Vidéo après soudure des LEDS&#039;&#039;&#039;&lt;br /&gt;
[[File:PSE2_main_pc_demo.mp4]]&lt;br /&gt;
&lt;br /&gt;
=== Lecture ISP ===&lt;br /&gt;
L&#039;objectif est maintenant d&#039;utiliser notre communication IN/OUT pour envoyer des commandes SPI à un microcontrôleur cible afin de lire sa signature (Device ID).&lt;br /&gt;
&lt;br /&gt;
==== Côté Carte (LUFA) ====&lt;br /&gt;
On modifie notre fonction &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;, afin d&#039;inclure la lecture ISP.&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On &#039;&#039;&#039;initialise&#039;&#039;&#039; le SPI&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void spi_init(void)&lt;br /&gt;
{&lt;br /&gt;
	SPI_DDR |= (1 &amp;lt;&amp;lt; SPI_MOSI) | (1 &amp;lt;&amp;lt; SPI_SCK) | (1 &amp;lt;&amp;lt; SPI_SS); // Définition des sorties&lt;br /&gt;
	SPI_DDR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI_MISO);								 // Définition de l&#039;entrée&lt;br /&gt;
	SPI_PORT |= (1 &amp;lt;&amp;lt; SPI_SS);									 // Désactivation du périphérique&lt;br /&gt;
	SPCR = (1 &amp;lt;&amp;lt; SPE) | (1 &amp;lt;&amp;lt; MSTR) | (1 &amp;lt;&amp;lt; SPR1) | (1 &amp;lt;&amp;lt; SPR0); // Activation SPI (SPE) en état maître (MSTR)&lt;br /&gt;
	SPSR &amp;amp;= ~(1 &amp;lt;&amp;lt; SPI2X);										 // horloge F_CPU/128 (SPI2X=0, SPR1=1,SPR0=1)&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On fait le &#039;&#039;&#039;transfert&#039;&#039;&#039; l&#039;octet. On place l&#039;octet à envoyer dans &amp;lt;code&amp;gt;SPDR&amp;lt;/code&amp;gt;, on attend que l&#039;octet arrive chez l&#039;esclave, puis on renvoie ce que nous envoie l&#039;esclave.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t spi_transfer(uint8_t data)&lt;br /&gt;
{&lt;br /&gt;
	SPDR = data; // Octet a envoyer&lt;br /&gt;
	while (!(SPSR &amp;amp; (1 &amp;lt;&amp;lt; SPIF)))&lt;br /&gt;
		; // Attente fin envoi (drapeau SPIF du statut)&lt;br /&gt;
	return SPDR;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; On réécrit la fonction qui gère la &#039;&#039;&#039;commande OUT&#039;&#039;&#039; du PC pour inclure le paquet SPI. Si l&#039;octet ne vaut pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on ne fait rien, sinon on applique au LED la valeurs du paquet OUT, comme précédemment. &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint8_t commande_PC = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
	if (Endpoint_IsOUTReceived())&lt;br /&gt;
	{&lt;br /&gt;
		if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
		{&lt;br /&gt;
			// On lit l&#039;octet envoyé par le PC&lt;br /&gt;
			commande_PC = Endpoint_Read_8();&lt;br /&gt;
			if (commande_PC != 0x01)&lt;br /&gt;
				// On l&#039;applique aux LEDs (PORTB)&lt;br /&gt;
				PORTB = commande_PC;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearOUT();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Pour la &#039;&#039;&#039;gestion du IN :&#039;&#039;&#039; si le paquet n&#039;est pas &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; alors on lit l&#039;état des boutons comme précemment. Sinon on active le SPI, et on applique le protocole ISP. Ce protocole consiste à envoyer une série de 4 octets dans un ordre bien spécifique, comme indiqué dans la datasheet &amp;lt;code&amp;gt;Atmel-0943-In-System-Programming_ApplicationNote_AVR910&amp;lt;/code&amp;gt; qu&#039;on peut retrouver dans le dossier &amp;lt;code&amp;gt;datasheet&amp;lt;/code&amp;gt;. &lt;br /&gt;
[[File : PSE2_ISP_command.png|center|1000x1000px]]&lt;br /&gt;
&#039;&#039;&#039;Que se passe-t-il pendant les 4 octets du protocole AVR ISP ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Le protocole ISP d&#039;Atmel est conçu pour que chaque instruction fasse exactement 32 bits (4 octets).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 (0x30) :&#039;&#039;&#039; Le Maître dit &amp;quot;Je veux lire la signature&amp;quot;. L&#039;Esclave reçoit ça, mais ne renvoie rien pour le moment.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 (0x00) :&#039;&#039;&#039; Le Maître envoie l&#039;adresse de poids fort (inutile ici). L&#039;Esclave est en train de comprendre la commande &amp;lt;code&amp;gt;0x30&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 3 (0x00, 0x01 ou 0x02) :&#039;&#039;&#039; Le Maître demande précisément l&#039;adresse 0, 1 ou 2 de la signature. L&#039;Esclave va chercher l&#039;information dans sa mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4 (0x00) :&#039;&#039;&#039; L&#039;Esclave a préparé la réponse (la signature), mais il ne contrôle pas l&#039;horloge ! Il a besoin que le Maître génère 8 coups d&#039;horloge pour que la réponse puisse voyager sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. Le Maître envoie donc un octet factice (0x00) uniquement pour faire tourner l&#039;horloge. Pendant ce temps, la cible glisse sa réponse sur le fil &amp;lt;code&amp;gt;MISO&amp;lt;/code&amp;gt;. C&#039;est pour ça qu&#039;on fait &amp;lt;code&amp;gt;uint8_t sig_n = spi_transfer(0x00);&amp;lt;/code&amp;gt; ! Le dernier octet retourné par la cible est la &#039;&#039;&#039;donnée recherchée&#039;&#039;&#039;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Pourquoi 3 octets de signature et qu&#039;est-ce qu&#039;on récupère ?&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
Chaque microcontrôleur AVR possède une &amp;quot;Signature&amp;quot; unique gravée en usine, composée de 3 octets (situés aux adresses 0, 1 et 2).&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 0 :&#039;&#039;&#039; Identifie le fabricant. Atmel est toujours &amp;lt;code&amp;gt;0x1E&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1 :&#039;&#039;&#039; Identifie la famille et la mémoire.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 2 :&#039;&#039;&#039; Identifie le modèle exact. Par exemple, le AT90S1200 a pour signature 0x1E 0x90 0x01.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File : PSE2_ISP_allowed_dev.png|left|750x200px]]&lt;br /&gt;
Voici le tableau qui résume ce protocole. On retrouve en ligne les 3 octets qu&#039;on reçoit et en colonne les 4 octets nécéssaires à la récupération de chacun de ces 3 octets.&lt;br /&gt;
[[File : PSE2_ISP_device_code.png|right|750x200px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
Voici la fonction qui met en place le protocole : &lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void ProcessIN(void)&lt;br /&gt;
{&lt;br /&gt;
	Endpoint_SelectEndpoint(DATA_IN_EPADDR);&lt;br /&gt;
	if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
	{&lt;br /&gt;
		if (commande_PC != 0x01)&lt;br /&gt;
			Endpoint_Write_8(PINC &amp;amp; 0xC0);&lt;br /&gt;
		else&lt;br /&gt;
		{&lt;br /&gt;
			// Mode ISP : Le PC a demandé les identifiants&lt;br /&gt;
			spi_ON();&lt;br /&gt;
            &lt;br /&gt;
            // (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
		&lt;br /&gt;
        	// --- Lecture du 1er octet de signature (Adresse 0x00) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			uint8_t sig_1 = spi_transfer(0x00); // La cible répond pendant cet octet&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 2ème octet de signature (Adresse 0x01) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x01);&lt;br /&gt;
			uint8_t sig_2 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			// --- Lecture du 3ème octet de signature (Adresse 0x02) ---&lt;br /&gt;
			spi_transfer(0x30);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x02);&lt;br /&gt;
			uint8_t sig_3 = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
&lt;br /&gt;
			// On envoie les 3 octets au PC !&lt;br /&gt;
			Endpoint_Write_8(sig_1);&lt;br /&gt;
			Endpoint_Write_8(sig_2);&lt;br /&gt;
			Endpoint_Write_8(sig_3);&lt;br /&gt;
&lt;br /&gt;
			// On efface la commande pour ne pas spammer la cible au prochain tour&lt;br /&gt;
			commande_PC = 0;&lt;br /&gt;
		}&lt;br /&gt;
		Endpoint_ClearIN();&lt;br /&gt;
	}&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Côté PC (libusb) ====&lt;br /&gt;
La fonction  &amp;lt;code&amp;gt;isp_ids.c&amp;lt;/code&amp;gt; permet l&#039;envoie d&#039;une commande qui implique la réception des identifiants ISP de l&#039;AVR. Il enverra la commande &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt;, puis écoutera le point d&#039;accès IN pour récupérer et afficher les 3 octets de la signature.&lt;br /&gt;
&lt;br /&gt;
===== OUT =====&lt;br /&gt;
On envoie simplement l&#039;octet &amp;lt;code&amp;gt;0x01&amp;lt;/code&amp;gt; pour activer le code ISP sur l&#039;avr (côté LUFA).&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----OUT----&lt;br /&gt;
unsigned char data_out = 0x01; // octet à envoyer pout l&#039;ISP (choix)&lt;br /&gt;
int actual_length;&lt;br /&gt;
&lt;br /&gt;
int r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;data_out, 1, &amp;amp;actual_length, 50);&lt;br /&gt;
if (r == 0)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Ordre envoyé : 0x%02X\n&amp;quot;, data_out);&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;[PC] Erreur OUT : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== IN =====&lt;br /&gt;
Pour récupérer les 3 octets, on doit d&#039;abord ignorer le premier paquet envoyé par les boutons (do/while). Ensuite on imprime les 3 octets reçu et on indique si c&#039;est un AVR atmel qu&#039;on connecte en ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
// ----IN ----&lt;br /&gt;
unsigned char data_in[3] = {0, 0, 0};&lt;br /&gt;
&lt;br /&gt;
printf(&amp;quot;[PC] Attente de la réponse (Purge des anciens paquets)...\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
// Boucle pour ignorer les paquets de 1 octet (les boutons)&lt;br /&gt;
// On boucle tant que le transfert réussit ET que la taille est de 1&lt;br /&gt;
do&lt;br /&gt;
{&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
} while (r == 0 &amp;amp;&amp;amp; actual_length == 1);&lt;br /&gt;
&lt;br /&gt;
// Sortie de boucle : on a soit une erreur, soit notre paquet de 3 octets !&lt;br /&gt;
if (r == 0 &amp;amp;&amp;amp; actual_length == 3)&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Signature reçue avec succès : 0x%02X 0x%02X 0x%02X\n&amp;quot;, data_in[0], data_in[1], data_in[2]);&lt;br /&gt;
&lt;br /&gt;
    if (data_in[0] == 0x1E)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;-&amp;gt; Fabricant : Atmel reconnu !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
else&lt;br /&gt;
{&lt;br /&gt;
    printf(&amp;quot;Erreur ou Timeout (reçu %d octets) : %s\n&amp;quot;, actual_length, libusb_error_name(r));&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Résultats====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./isp_ids  &lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Résultat avant soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0xFF 0xFF 0xFF&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Résultat après soudure de l&#039;ISP :&#039;&#039;&#039;&lt;br /&gt;
Test sur une Arduino UNO&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
[PC] Ordre envoyé : 0x01&lt;br /&gt;
[PC] Attente de la réponse (Purge des anciens paquets)...&lt;br /&gt;
Signature reçue avec succès : 0x1E 0x95 0x0F&lt;br /&gt;
-&amp;gt; Fabricant : Atmel reconnu !&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Flash ===&lt;br /&gt;
L&#039;objectif est de récupérer l&#039;intégralité du contenu de la mémoire flash de la cible. Celle-ci étant volumineuse, le&lt;br /&gt;
transfert se fait par blocs de 8 octets (soit 4 mots de 16 bits).&lt;br /&gt;
&lt;br /&gt;
==== Envoyer bloc par bloc sur le IN ====&lt;br /&gt;
===== Modification de la LUFA (main.c) =====&lt;br /&gt;
Du côté de la &amp;lt;code&amp;gt;LUFA&amp;lt;/code&amp;gt;, nous modifions le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; pour gérer un adressage sur 16 bits et utiliser&lt;br /&gt;
les commandes de lecture flash définies dans la datasheet (AVR910).&lt;br /&gt;
&lt;br /&gt;
L&#039;adresse de lecture est envoyée par le PC via le point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, puis la carte lit 8 octets en&lt;br /&gt;
&amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt; et les renvoie via le point d&#039;accès &amp;lt;code&amp;gt;IN&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Comprendre la lecture de la Flash via ISP :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Selon le document technique (Table 3-5), la lecture de la mémoire flash se fait mot par mot (un mot = 2 octets).&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read Low Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Read High Byte&#039;&#039;&#039; : Commande &amp;lt;code&amp;gt;0x28&amp;lt;/code&amp;gt; suivi de l&#039;adresse.&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	Le format d&#039;une commande est toujours de 4 octets:&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 1&#039;&#039;&#039; : &amp;lt;code&amp;gt;0x20&amp;lt;/code&amp;gt; (Low) ou 0x28 (High).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octets 2 et 3&#039;&#039;&#039; : L&#039;adresse du mot (poids fort puis poids faible)&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Octet 4&#039;&#039;&#039; : Donnée fictive (&amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt;) pour récupérer la réponse de la cible.&amp;lt;/li&amp;gt;&lt;br /&gt;
	[[file : PSE2_flash_reading.png|centre|1000x1000px]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;CODE (main.c):&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Modification de la fonction &amp;lt;code&amp;gt;ProcessOUT()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		On prépare la demande du code &amp;lt;code&amp;gt;PC&amp;lt;/code&amp;gt;. Une fois que celui-ci aura envoyé &amp;lt;code&amp;gt;0X02&amp;lt;/code&amp;gt;, le&lt;br /&gt;
		programmeur AVR &amp;quot;sait&amp;quot; qu&#039;il va recevoir 2 octets contenant l&#039;adresse désirée par le PC.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
uint16_t flash_address = 0;&lt;br /&gt;
void ProcessOUT(void)&lt;br /&gt;
{&lt;br /&gt;
    Endpoint_SelectEndpoint(DATA_OUT_EPADDR);&lt;br /&gt;
    if (Endpoint_IsOUTReceived())&lt;br /&gt;
    {&lt;br /&gt;
        if (Endpoint_IsReadWriteAllowed())&lt;br /&gt;
        {&lt;br /&gt;
            // On lit l&#039;octet envoyé par le PC&lt;br /&gt;
            commande_PC = Endpoint_Read_8();&lt;br /&gt;
            if (commande_PC == 0x02) // Demande de lecture Flash&lt;br /&gt;
            {&lt;br /&gt;
                flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
                flash_address |= Endpoint_Read_8();                 // Poids faible&lt;br /&gt;
            }&lt;br /&gt;
            else if (commande_PC != 0x01)&lt;br /&gt;
            {&lt;br /&gt;
                PORTB = commande_PC; // Gestion des LEDs } }&lt;br /&gt;
                Endpoint_ClearOUT();&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;Ajout du &amp;lt;code&amp;gt;if&amp;lt;/code&amp;gt; dans la fonction &amp;lt;code&amp;gt;ProcessIN()&amp;lt;/code&amp;gt; :&#039;&#039;&#039;&lt;br /&gt;
		Comme indiqué précédemment, on va lire la flash à l&#039;adresse demandée par le PC. Comme dans&lt;br /&gt;
		&amp;lt;code&amp;gt;descriptor.h&amp;lt;/code&amp;gt; on a mis &amp;lt;code&amp;gt;#define DATA_SIZE 8&amp;lt;/code&amp;gt;(plus lent mais plus intéressant pour&lt;br /&gt;
		comprendre) et qu&#039;un mot fait 2 octets, alors cela veut dire qu&#039;on peut lire jusqu&#039;à 4 mots à&lt;br /&gt;
		&amp;lt;code&amp;gt;flash_address + i&amp;lt;/code&amp;gt; pour optimiser la bande passante USB (d&#039;ou le i jusqu&#039;à 4 dans le&lt;br /&gt;
		&amp;lt;code&amp;gt;for&amp;lt;/code&amp;gt;).&lt;br /&gt;
		Ensuite on suit le protocole expliqué au dessus pour la lecture de la flash pour chaque mots lu.&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
        if (commande_PC == 0x02)&lt;br /&gt;
		{&lt;br /&gt;
			spi_ON();&lt;br /&gt;
&lt;br /&gt;
			// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
			spi_transfer(0xAC);&lt;br /&gt;
			spi_transfer(0x53);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
			spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
			for (uint16_t i = 0; i &amp;lt; 4; i++)&lt;br /&gt;
			{&lt;br /&gt;
				uint16_t current_addr = flash_address + i;&lt;br /&gt;
&lt;br /&gt;
				// Lecture du Low Byte&lt;br /&gt;
				spi_transfer(0x20);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);   // On décale de 8 les 2 octets donc on a 0x00HIGH = 0xHIGH&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF); // On fait un &amp;amp; à l&#039;adresse avec 0x00FF donc on a 0x00LOW = 0xLOW&lt;br /&gt;
				uint8_t data_low = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Lecture du High Byte&lt;br /&gt;
				spi_transfer(0x28);&lt;br /&gt;
				spi_transfer(current_addr &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(current_addr &amp;amp; 0xFF);&lt;br /&gt;
				uint8_t data_hight = spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// envoie au PC&lt;br /&gt;
				Endpoint_Write_8(data_low);&lt;br /&gt;
				Endpoint_Write_8(data_hight);&lt;br /&gt;
			}&lt;br /&gt;
			spi_OFF();&lt;br /&gt;
			commande_PC = 0; // On a fini d&#039;envoyer le bloc&lt;br /&gt;
		}&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Récéption PC (flash_read.c)=====&lt;br /&gt;
Comme on a programmé notre AVR pour qu&#039;elle récupère 4 mots par adresses données, il faut qu&#039;on lui donne des adresses&lt;br /&gt;
indentées de 4.&lt;br /&gt;
Par exemple si on veut lire 64 octets de la flash (soit 32 mots), on boucle de cette manière :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0000&amp;lt;/code&amp;gt; (la carte renvoie les mots 0, 1, 2, 3).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0004&amp;lt;/code&amp;gt; (la carte renvoie les mots 4, 5, 6, 7).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;Demander l&#039;adresse &amp;lt;code&amp;gt;0x0008&amp;lt;/code&amp;gt; (la carte renvoie les mots 8, 9, 10, 11).&amp;lt;/li&amp;gt;&lt;br /&gt;
	&amp;lt;li&amp;gt;...&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
	Le code ci-dessous effectue cette boucle afin de récupérer 64 octets dans la flash cible.&lt;br /&gt;
	&amp;lt;li&amp;gt;&#039;&#039;&#039;flash_read.c :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
printf(&amp;quot;\n=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===\n\n&amp;quot;);&lt;br /&gt;
int r;&lt;br /&gt;
int actual_length;&lt;br /&gt;
unsigned char data_out[3];&lt;br /&gt;
unsigned char data_in[8]; // Tampon de 8 octets pour recevoir 4 mots&lt;br /&gt;
&lt;br /&gt;
// Boucle pour lire 32 mots (64 octets), par pas de 4 mots&lt;br /&gt;
for (uint16_t addr = 0; addr &amp;lt; 32; addr += 4)&lt;br /&gt;
{ // Préparation de la commande OUT (0x02 + Addr_High + Addr_Low)&lt;br /&gt;
    data_out[0] = 0x02;&lt;br /&gt;
    data_out[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // Poids fort de l&#039;adresse&lt;br /&gt;
    data_out[2] = addr &amp;amp; 0xFF;        // Poids faible de l&#039;adresse&lt;br /&gt;
&lt;br /&gt;
    // Demande de lecture en OUT&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_out, 3, &amp;amp;actual_length, 100);&lt;br /&gt;
    if (r != 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de la demande pour l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        continue;&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // Réception IN (avec supression des paquets &amp;quot;boutons&amp;quot; d&#039;1 octet)&lt;br /&gt;
    do&lt;br /&gt;
    {&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_IN, data_in, 8, &amp;amp;actual_length, 100);&lt;br /&gt;
    } while (r == 0 &amp;amp;&amp;amp; actual_length == 1); // Ignore les paquets de boutons&lt;br /&gt;
&lt;br /&gt;
    // Affichage du bloc reçu&lt;br /&gt;
    if (r == 0 &amp;amp;&amp;amp; actual_length == 8)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Adresse 0x%04X : &amp;quot;, addr);&lt;br /&gt;
        for (int i = 0; i &amp;lt; 8; i += 2)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;%04X &amp;quot;, (data_in[i + 1] &amp;lt;&amp;lt; 8) | data_in[i]);&lt;br /&gt;
        }&lt;br /&gt;
        printf(&amp;quot; \n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur de lecture a l&#039;adresse 0x%04X (reçu %d octets)\n&amp;quot;, addr,&lt;br /&gt;
               actual_length);&lt;br /&gt;
    }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
	&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_read&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0004 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure (UNO):&#039;&#039;&#039;&lt;br /&gt;
		&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : 940C 005D 940C 0085 &lt;br /&gt;
Adresse 0x0004 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0008 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x000C : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0010 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0014 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x0018 : 940C 0085 940C 0085 &lt;br /&gt;
Adresse 0x001C : 940C 0085 940C 0085 &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
		&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Mise à jour de la flash (Page Mode) ====&lt;br /&gt;
L&#039;objectif est d&#039;écrire de nouvelles données dans la mémoire Flash de la cible. Étant donné que les cibles modernes comme l&#039;ATmega328P (Arduino) ne supportent plus l&#039;écriture octet par octet (Byte Mode), nous nous appuyons sur la Datasheet de l&#039;ATmega328P (Section Serial Downloading) pour utiliser le mode de programmation par page (Page Mode).&lt;br /&gt;
&lt;br /&gt;
===== Mécanisme d&#039;écriture SPI =====&lt;br /&gt;
[[File: PSE2_flash_writting_page_mode.png|right|600x600px]]&lt;br /&gt;
L&#039;écriture dans la Flash nécessite désormais de précharger les données dans un tampon temporaire (Page Buffer) avant de déclencher la gravure physique de la page. Pour simplifier notre programme PC, nous chargeons un seul mot (16 bits) dans le tampon, puis nous forçons immédiatement la gravure.&lt;br /&gt;
&lt;br /&gt;
La session se fait en un seul cycle d&#039;activation de la cible (spi_ON) :&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Activation de la mémoire (Enable Memory Access)&#039;&#039;&#039; : Envoi de la séquence &amp;lt;code&amp;gt;0xAC 0x53 0x00 0x00&amp;lt;/code&amp;gt; obligatoire pour déverrouiller l&#039;accès.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du Low Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet faible pour le placer dans le tampon.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Chargement du High Byte)&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x48&amp;lt;/code&amp;gt; suivie de l&#039;adresse et de l&#039;octet fort.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Déclenchement du Write Page&#039;&#039;&#039; : Utilisation de la commande &amp;lt;code&amp;gt;0x4C&amp;lt;/code&amp;gt; suivie de l&#039;adresse pour graver physiquement le tampon dans la Flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Attente&#039;&#039;&#039; : Délai de quelques millisecondes (environ 5 ms) pour laisser le matériel terminer l&#039;écriture avant de relâcher le &amp;lt;code&amp;gt;RESET&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== Implémentation LUFA (main.c) =====&lt;br /&gt;
Pour pourvoir écrire dans la flash cible il faut effacer la flah. Pour ça on a fait la fonction &amp;lt;code&amp;gt;chip_erase()&amp;lt;/code&amp;gt; qui suit le protocole du tableau.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
void chip_erase(void)&lt;br /&gt;
{&lt;br /&gt;
	spi_ON();&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x53);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	// (3.4.3 datasheet) erase&lt;br /&gt;
	spi_transfer(0xAC);&lt;br /&gt;
	spi_transfer(0x80);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	spi_transfer(0x00);&lt;br /&gt;
	_delay_ms(5);&lt;br /&gt;
	spi_OFF();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
Dans notre point d&#039;accès &amp;lt;code&amp;gt;OUT&amp;lt;/code&amp;gt;, nous créons la commande &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt;. Le programme PC enverra un paquet&lt;br /&gt;
contenant l&#039;adresse cible et les deux octets à écrire. La carte exécute ensuite la séquence &amp;lt;code&amp;gt;SPI&amp;lt;/code&amp;gt;. On crée la commande &amp;lt;code&amp;gt;0x04&amp;lt;/code&amp;gt; pour erase la flash.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
            else if (commande_PC == 0x03) // Ecriture de flash (flash_rw.c)&lt;br /&gt;
			{&lt;br /&gt;
				flash_address = ((uint16_t)Endpoint_Read_8() &amp;lt;&amp;lt; 8); // Poids fort&lt;br /&gt;
				flash_address |= Endpoint_Read_8();					// Poids faible&lt;br /&gt;
				uint8_t low = Endpoint_Read_8();&lt;br /&gt;
				uint8_t high = Endpoint_Read_8();&lt;br /&gt;
&lt;br /&gt;
				spi_ON();&lt;br /&gt;
				_delay_ms(5); // Temps de réveil cible&lt;br /&gt;
&lt;br /&gt;
				// (3.2 datasheet) Enable Memory Access&lt;br /&gt;
				spi_transfer(0xAC);&lt;br /&gt;
				spi_transfer(0x53);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				// Low byte&lt;br /&gt;
				spi_transfer(0x40);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(low);&lt;br /&gt;
&lt;br /&gt;
				// High byte&lt;br /&gt;
				spi_transfer(0x48);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(high);&lt;br /&gt;
&lt;br /&gt;
				// Write&lt;br /&gt;
				spi_transfer(0x4C);&lt;br /&gt;
				spi_transfer(flash_address &amp;gt;&amp;gt; 8);&lt;br /&gt;
				spi_transfer(flash_address &amp;amp; 0xFF);&lt;br /&gt;
				spi_transfer(0x00);&lt;br /&gt;
&lt;br /&gt;
				_delay_ms(5); // Attente de la gravure physique&lt;br /&gt;
				spi_OFF();&lt;br /&gt;
			}&lt;br /&gt;
			else if (commande_PC == 0x04)&lt;br /&gt;
			{&lt;br /&gt;
				chip_erase();&lt;br /&gt;
			}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===== PC(flash_rw.c) =====&lt;br /&gt;
Pour tester l&#039;écriture, on fait une fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; qui écrit dans la flash cible puis la lit.&lt;br /&gt;
Pour écrire dans la flash cible, on doit d&#039;abord effacer la flash, puis on envoi l’octet &amp;lt;code&amp;gt;0x03&amp;lt;/code&amp;gt; (choisit par défaut). Ensuite on&lt;br /&gt;
envoi l&#039;adresse ou on veut écrire la donnée; en 2 octets HIGH/LOW, et de même pour la donnée à envoyer.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    int r;&lt;br /&gt;
    int actual_length;&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 0. EFFACEMENT DE LA CIBLE (Chip Erase)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== EFFACEMENT DE LA PUCE ===\n&amp;quot;);&lt;br /&gt;
    unsigned char cmd_erase = 0x04;&lt;br /&gt;
&lt;br /&gt;
    r = libusb_interrupt_transfer(dev_handle, EP_OUT, &amp;amp;cmd_erase, 1, &amp;amp;actual_length, 500);&lt;br /&gt;
    if (r == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Puce effacée avec succès !\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;Erreur lors de l&#039;effacement : %s\n&amp;quot;, libusb_error_name(r));&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    // 1. TEST D&#039;ÉCRITURE (Byte Mode)&lt;br /&gt;
    // =========================================================&lt;br /&gt;
    printf(&amp;quot;\n=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===\n\n&amp;quot;);&lt;br /&gt;
    unsigned char data_write[5]; // Paquet de 5 octets pour l&#039;écriture&lt;br /&gt;
&lt;br /&gt;
    // On boucle sur les 4 premières adresses de mots (0, 1, 2, 3)&lt;br /&gt;
    for (uint16_t addr = 0; addr &amp;lt; 5; addr++)&lt;br /&gt;
    {&lt;br /&gt;
        // On invente une donnée factice pour le test (ex: 0xA000, 0xA001...)&lt;br /&gt;
        uint16_t fake_data = 0xA000 + addr;&lt;br /&gt;
&lt;br /&gt;
        // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
        data_write[0] = 0x03;                    // Commande d&#039;écriture&lt;br /&gt;
        data_write[1] = (addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;      // add HIGH&lt;br /&gt;
        data_write[2] = addr &amp;amp; 0xFF;             // add LOW&lt;br /&gt;
        data_write[3] = fake_data &amp;amp; 0xFF;        // fake LOW&lt;br /&gt;
        data_write[4] = (fake_data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // fake HIGH&lt;br /&gt;
&lt;br /&gt;
        // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
        r = libusb_interrupt_transfer(dev_handle, EP_OUT, data_write, 5, &amp;amp;actual_length, 100);&lt;br /&gt;
        if (r == 0)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x%04X | Donnée: 0x%04X\n&amp;quot;, addr, fake_data);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;Erreur d&#039;écriture à l&#039;adresse 0x%04X : %s\n&amp;quot;, addr, libusb_error_name(r));&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====RESULTATS=====&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./flash_rw&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Avant soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;i&amp;gt;RQ : la lecture renvoie quand même que des mots en &amp;lt;code&amp;gt;FFFF&amp;lt;/code&amp;gt;&amp;lt;/i&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Après soudure :&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
=== EFFACEMENT DE LA PUCE ===&lt;br /&gt;
Puce effacée avec succès !&lt;br /&gt;
&lt;br /&gt;
=== ECRITURE DE LA FLASH (Test : 4 premiers mots) ===&lt;br /&gt;
&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0000 | Donnée: 0xA000&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0001 | Donnée: 0xA001&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0002 | Donnée: 0xA002&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0003 | Donnée: 0xA003&lt;br /&gt;
Ordre d&#039;écriture envoyé -&amp;gt; Adresse: 0x0004 | Donnée: 0xA004&lt;br /&gt;
&lt;br /&gt;
=== LECTURE DE LA FLASH (Test : 64 premiers octets) ===&lt;br /&gt;
&lt;br /&gt;
Adresse 0x0000 : A000 A001 A002 A003 &lt;br /&gt;
Adresse 0x0004 : A004 FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0008 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x000C : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0010 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0014 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x0018 : FFFF FFFF FFFF FFFF &lt;br /&gt;
Adresse 0x001C : FFFF FFFF FFFF FFFF &lt;br /&gt;
&lt;br /&gt;
Fermeture du programme...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Assemblage(résultats) ===&lt;br /&gt;
L&#039;objectif est d&#039;utiliser les fonctions test et de les modifier afin de d&#039;avoir un seul programme &amp;lt;code&amp;gt;main&amp;lt;/code&amp;gt; qui contrôle tout. On l&#039;appel &amp;lt;code&amp;gt;prog.c&amp;lt;/code&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
La première chose est de retirer la gestion USB dans &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;flash_read.c&amp;lt;/code&amp;gt; et de la séparer dans une fonction &amp;lt;code&amp;gt;dev_handler.c&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
On change la fonction &amp;lt;code&amp;gt;flash_rw.c&amp;lt;/code&amp;gt; en &amp;lt;code&amp;gt;flash_write.c&amp;lt;/code&amp;gt; pour seulement écrire avec.&amp;lt;br&amp;gt;&lt;br /&gt;
Enfin on compile tout avec un &amp;lt;code&amp;gt;Makefile&amp;lt;/code&amp;gt; et on exécute le code avec une commande intelligente.&lt;br /&gt;
Ici on flashera un code basique &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; qui fera clignoter la LED PB5 de l&#039;arduino UNO.&lt;br /&gt;
&lt;br /&gt;
====Comment flasher un programme C ?====&lt;br /&gt;
Pour flasher un fichier C il faut écrire le &amp;lt;code&amp;gt;.hex&amp;lt;/code&amp;gt; associé. La compilation d&#039;un .hex est détaillée dans &amp;quot;Programateur/libusb/code_a_televerser/Makefile&amp;quot;.&amp;lt;br&amp;gt;&lt;br /&gt;
Un fichier .hex est composé de lignes d&#039;octets qui ont une fonction bien précise. &amp;lt;br&amp;gt;&lt;br /&gt;
On prend par exemple la première ligne dans &amp;lt;code&amp;gt;blink.hex&amp;lt;/code&amp;gt; : &amp;lt;code&amp;gt;:100000000C9434000C943E000C943E000C943E0082&amp;lt;/code&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;:&amp;lt;/code&amp;gt; : indique le début d&#039;un ligne&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;10&amp;lt;/code&amp;gt; : Nombre d&#039;octets de données sur cette ligne (Ici &amp;lt;code&amp;gt;0x10&amp;lt;/code&amp;gt; = &amp;lt;code&amp;gt;16&amp;lt;/code&amp;gt; octets).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0000&amp;lt;/code&amp;gt; : L&#039;adresse de départ en Flash pour cette ligne.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; : Type de ligne (&amp;lt;code&amp;gt;00&amp;lt;/code&amp;gt; = données à flasher, &amp;lt;code&amp;gt;01&amp;lt;/code&amp;gt; = fin du fichier).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&amp;lt;code&amp;gt;0C9434000C94...&amp;lt;/code&amp;gt; : Les données du programme&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====flash_write.c====&lt;br /&gt;
On applique cette logique dans notre nouvelle fonction.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour séparer ligne par ligne on utilise la fonction &amp;lt;code&amp;gt;fgets&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour sectionner ces ligne on utilise la fonction &amp;lt;code&amp;gt;sscanf&amp;lt;/code&amp;gt;. (Ces 2 fonctions on été vues en Structure de Données Avancées).&amp;lt;br&amp;gt;&lt;br /&gt;
Le reste est détaillés dans les commentaires du code.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
    char line[256];&lt;br /&gt;
    unsigned int length, addr_in, type_in;&lt;br /&gt;
    while (fgets(line, sizeof(line), file) != NULL)&lt;br /&gt;
    {&lt;br /&gt;
        sscanf(line, &amp;quot;:%2x%4x%2x&amp;quot;, &amp;amp;length, &amp;amp;addr_in, &amp;amp;type_in);&lt;br /&gt;
        uint16_t type = (uint16_t)type_in;&lt;br /&gt;
        if (type == 0x01)&lt;br /&gt;
            break;&lt;br /&gt;
        if (type == 0x00)&lt;br /&gt;
        {&lt;br /&gt;
            // Du côté du fichier .HEX l&#039;adresse est codé octet par octet. Contrairement à l&#039;AVR qui stock des adresses de mots. Donc pour avoir l&#039;adresse du mot(2 octets) il suffit de diviser l&#039;adresse in par 2.&lt;br /&gt;
            uint16_t current_word_addr = addr_in / 2;&lt;br /&gt;
&lt;br /&gt;
            for (unsigned int i = 0; i &amp;lt; length; i += 2)&lt;br /&gt;
            {&lt;br /&gt;
                unsigned int word_data;&lt;br /&gt;
                // On décale le point de départ du sscanf de 9 (début des octets du code) puis on l&#039;avance d&#039;un facteur de 2 par rapport à i. Comme i aussi avance d&#039;un facteur de 2 alors le tout avance d&#039;un facteur de 4. Comme on lit 4 valeurs ascii à la fois (en effet 1 octet = 2 valeurs ascii =&amp;gt; 2 octets = 1 mot = 4 valeurs ascii) le décallage est respécté.&lt;br /&gt;
                sscanf(line + 9 + (i * 2), &amp;quot;%4x&amp;quot;, &amp;amp;word_data);&lt;br /&gt;
                uint16_t data = ((word_data &amp;amp; 0xFF) &amp;lt;&amp;lt; 8) | (word_data &amp;gt;&amp;gt; 8);&lt;br /&gt;
&lt;br /&gt;
                // Préparation du paquet selon le protocole LUFA&lt;br /&gt;
                data_write[0] = 0x03;                            // Commande d&#039;écriture&lt;br /&gt;
                data_write[1] = (current_word_addr &amp;gt;&amp;gt; 8) &amp;amp; 0xFF; // add HIGH&lt;br /&gt;
                data_write[2] = current_word_addr &amp;amp; 0xFF;        // add LOW&lt;br /&gt;
                data_write[3] = data &amp;amp; 0xFF;                     // LOW&lt;br /&gt;
                data_write[4] = (data &amp;gt;&amp;gt; 8) &amp;amp; 0xFF;              // HIGH&lt;br /&gt;
&lt;br /&gt;
                // Envoi de l&#039;ordre d&#039;écriture en OUT&lt;br /&gt;
                ...&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
====Programme principale (prog.c)====&lt;br /&gt;
Ce programme relie toutes les fonctions vues avant. Il récupère d&#039;abord les identifiants de la cible via le protocole ISP. Ensuite il laisse le choix entre lire ou écrire la flash cible.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Structure cible=====&lt;br /&gt;
Tout d&#039;abord pour bien différencier la cible, on cré une structure cible:&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
typedef struct&lt;br /&gt;
{&lt;br /&gt;
    unsigned char signature[3];&lt;br /&gt;
    const char *nom;&lt;br /&gt;
    uint32_t taille_flash; // Taille totale en octets&lt;br /&gt;
    uint16_t taille_page;  // Taille d&#039;une page en octets&lt;br /&gt;
} CibleAVR;&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====Base de Donnée=====&lt;br /&gt;
On a créé une base de donnée pour avoir les informations exactes des puces si elles sont reconnues via le protocole ISP.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
const CibleAVR base_de_donnees[] = {&lt;br /&gt;
    {{0x1E, 0x95, 0x0F}, &amp;quot;ATmega328P&amp;quot;, 32768, 128},&lt;br /&gt;
    {{0x1E, 0x94, 0x89}, &amp;quot;ATmega16U2&amp;quot;, 16384, 128},&lt;br /&gt;
    {{0x1E, 0x93, 0x0B}, &amp;quot;ATtiny85&amp;quot;, 8192, 64}};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
On créé ensuite une fonction qui cherche la puce dans la BDD :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#define NB_CIBLES (sizeof(base_de_donnees) / sizeof(CibleAVR))&lt;br /&gt;
const CibleAVR *recherche_cible(unsigned char sig[3])&lt;br /&gt;
{&lt;br /&gt;
    for (long unsigned int i = 0; i &amp;lt; NB_CIBLES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        if (sig[0] == base_de_donnees[i].signature[0] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[1] == base_de_donnees[i].signature[1] &amp;amp;&amp;amp;&lt;br /&gt;
            sig[2] == base_de_donnees[i].signature[2])&lt;br /&gt;
        {&lt;br /&gt;
            return &amp;amp;base_de_donnees[i];&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    return NULL; // Puce inconnue&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=====main=====&lt;br /&gt;
On utilise des variables dans notre fonction main() pour pouvoir rajouter des fonctions : si on écrit &amp;lt;code&amp;gt;-read&amp;lt;/code&amp;gt; ou &amp;lt;code&amp;gt;-write&amp;lt;/code&amp;gt; après le nom de notre programme on peut soit lire ou écrire la flash cible.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(int argc, char *argv[])&lt;br /&gt;
{&lt;br /&gt;
    // Initialisation unique&lt;br /&gt;
    libusb_device_handle *dev_handle = init_usb();&lt;br /&gt;
    if (dev_handle == NULL)&lt;br /&gt;
        return 1;&lt;br /&gt;
    if (reclamer_interface(dev_handle) &amp;lt; 0)&lt;br /&gt;
        return 1;&lt;br /&gt;
&lt;br /&gt;
    // On récupère les infos de la cible si elle est connue.&lt;br /&gt;
    unsigned char sig[3] = {0, 0, 0};&lt;br /&gt;
    isp_ids(dev_handle, sig);&lt;br /&gt;
    const CibleAVR *cible = recherche_cible(sig);&lt;br /&gt;
    if (cible == NULL)&lt;br /&gt;
        printf(&amp;quot;\033[31mLa cible est inconnue.\033[0m\n&amp;quot;);&lt;br /&gt;
    else&lt;br /&gt;
        printf(&amp;quot;La cible est une %s, elle a une flash de \033[33m%d\033[0m octets et des pages de \033[33m%d\033[0m octets.\n&amp;quot;, cible-&amp;gt;nom, cible-&amp;gt;taille_flash, cible-&amp;gt;taille_page);&lt;br /&gt;
    // commandes utilisateur&lt;br /&gt;
    if (argc == 1)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\033[31mErreur : Vous devez préciser une action.\033[0m\n&amp;quot;);&lt;br /&gt;
        printf(&amp;quot;Usage : make read OU make write &amp;lt;fichier.hex&amp;gt;\n&amp;quot;);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-read&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        printf(&amp;quot;\nLancement de la lecture...\n&amp;quot;);&lt;br /&gt;
        flash_read(dev_handle, cible-&amp;gt;taille_flash);&lt;br /&gt;
    }&lt;br /&gt;
    else if (strcmp(argv[1], &amp;quot;-write&amp;quot;) == 0)&lt;br /&gt;
    {&lt;br /&gt;
        if (argc &amp;lt; 3)&lt;br /&gt;
        {&lt;br /&gt;
            printf(&amp;quot;\033[31mErreur : Il manque le nom du fichier .hex !\033[0m\n&amp;quot;);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            FILE *file = fopen(argv[2], &amp;quot;r&amp;quot;);&lt;br /&gt;
            if (file == NULL)&lt;br /&gt;
                printf(&amp;quot;\033[31mErreur : Impossible d&#039;ouvrir le fichier %s.\033[0m\n&amp;quot;, argv[2]);&lt;br /&gt;
            else&lt;br /&gt;
            {&lt;br /&gt;
                printf(&amp;quot;\nOuverture du fichier %s...\n&amp;quot;, argv[2]);&lt;br /&gt;
                flash_write(dev_handle, file);&lt;br /&gt;
                printf(&amp;quot;\033[32mÉcriture terminée avec succès !\033[0m\n&amp;quot;);&lt;br /&gt;
                fclose(file);&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // Fermeture unique et propre&lt;br /&gt;
    printf(&amp;quot;\nFermeture globale du programme...\n&amp;quot;);&lt;br /&gt;
    libusb_release_interface(dev_handle, 0);&lt;br /&gt;
    libusb_close(dev_handle);&lt;br /&gt;
    libusb_exit(NULL);&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;
=====RESULTATS=====&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Compilation dans libusb/code_a_televerser/&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
make clean &amp;amp;&amp;amp; make&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&#039;&#039;&#039;Execution du code&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; écriture &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -write blink.hex&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_write.mp4]]&lt;br /&gt;
&lt;br /&gt;
&amp;lt;li&amp;gt; lecture &amp;lt;/li&amp;gt;&lt;br /&gt;
On lit bien ce qu&#039;on a écrit juste avant.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;bash&amp;quot;&amp;gt;&lt;br /&gt;
sudo ./build/prog -read&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File : PSE2_read.mp4]]&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Bilan ==&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure presque terminée. LEDs et résistances associées manquantes, 1 bouton poussoir traversant manquant.&lt;br /&gt;
 &lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : Problème ISP -&amp;gt; connexion ISP&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Problème&#039;&#039;&#039; : le programmateur n&#039;est pas détecté en USB. Un erreur est détectée ce qui montre qu&#039;il y a une connexion, mais n&#039;apparaît pas dans &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;. &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Programmable : La connexion en ISP en revanche fonctionne. On pourra donc programmer les leds et les boutons avec une UNO. Voir dans le futur si on peut fixer le problème de l&#039;USB pour rendre le programmateur fonctionnel.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;ajout d&#039;un premier &amp;lt;code&amp;gt;blink_led.c&amp;lt;/code&amp;gt; (brouillon) au git&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;TESTS : Le code &amp;lt;code&amp;gt;blink&amp;lt;/code&amp;gt; fonctionne mais pas le code &amp;lt;code&amp;gt;boutons&amp;lt;/code&amp;gt; -&amp;gt; faut contact / pbs de soudure sur les pattes&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;11/03 : fonctions test&amp;lt;/h3&amp;gt;&lt;br /&gt;
LEDS et boutons fonctionnent -&amp;gt; attente de réparation de notre USB par le prof ou fin de projet pour le programatteur.&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;08/04 : impression de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Nouvelle carte imprimée et détection de notre carte via &amp;lt;code&amp;gt;lsusb&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
[[File:BE2_lsusb.png|left|sans_cadre|712x712px]][[File:BE2_lsusb_details.png|right|sans_cadre|713x792px]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;17/04 : minicom&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;minicom&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/04 : codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;InOut&amp;lt;/code&amp;gt; test et ISP.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(19-26)/04 : suite codes test vérifiables avant soudure&amp;lt;/h3&amp;gt;&lt;br /&gt;
Programmation &amp;lt;code&amp;gt;flash&amp;lt;/code&amp;gt;,&amp;lt;code&amp;gt;ISP&amp;lt;/code&amp;gt;, fonctions test OK avant soudure.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;28/04 : Soudure de la nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
Soudure des leds et du composants ISP de la carte. Modification des fonctions test pour faire fonctionner le code sur une atemaga328p(UNO). &amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;02/05 : finition du projet&amp;lt;/h3&amp;gt;&lt;br /&gt;
Finition du projet : le programmeur est capable de transférer un code C sur une AVR (3 AVR sont ajoutées dans la BDD du programmeur).&amp;lt;br&amp;gt;&lt;br /&gt;
Un code simple &amp;lt;code&amp;gt;blink.c&amp;lt;/code&amp;gt; est testé et fonctionnel sur une arduino UNO (atemage328p). &amp;lt;br&amp;gt;&lt;br /&gt;
Tout les détails du projets sont indiqués dans la section &amp;quot;Programmation&amp;quot; détaillés étape par étape.&amp;lt;br&amp;gt;&lt;br /&gt;
Le code/résultat final est dans la sous section &amp;quot;Assemblage&amp;quot; de la section &amp;quot;Programmation&amp;quot;.&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Sur le &#039;&#039;&#039;git&#039;&#039;&#039;, on retrouve le contenu nécessaire dans &amp;lt;code&amp;gt;Programmeur/&amp;lt;/code&amp;gt;. L&#039;utilisation du code est décris dans le &amp;lt;code&amp;gt;README&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
= Premier système embarqué =&lt;br /&gt;
&lt;br /&gt;
== Archive GIT ==&lt;br /&gt;
&lt;br /&gt;
Notre archive GIT pour le projet KiCAD et pour les programmes : https://gitea.plil.fr/mterrier/2025_PSE_B2_mterrier_jramesh&lt;br /&gt;
&lt;br /&gt;
Structure avec matériel (y compris production - gerber, bill of materials) / logiciel / documentation (e.g. documentation technique).&lt;br /&gt;
&lt;br /&gt;
== Description du système embarqué ==&lt;br /&gt;
Nous avons décider de réaliser &#039;&#039;&#039;BMO&#039;&#039;&#039;, un système comportant un &#039;&#039;&#039;écran&#039;&#039;&#039; affichant un visage minimaliste, munis d&#039;un &#039;&#039;&#039;détécteur de mouvement&#039;&#039;&#039; et d&#039;un &#039;&#039;&#039;buzzer&#039;&#039;&#039;.&lt;br /&gt;
&lt;br /&gt;
Lorsque notre main s&#039;approche de détécteur, le visage plisse les yeux (ou devient triste). Lorsque notre main s&#039;écarte de celui ci, le visage réouvre les yeux (ou devient heureux).&lt;br /&gt;
&lt;br /&gt;
Le système sera alimenté par une &#039;&#039;&#039;batterie&#039;&#039;&#039;, ou une alimentation &#039;&#039;&#039;USB&#039;&#039;&#039; en 5V.&lt;br /&gt;
&lt;br /&gt;
Afin de valider l&#039;utilisation du port USB, nous connecterons un ordinateur au système via USB et éffectuerons un transfert de données sonores (divers sons) qu&#039;on ira stocker dans la flash. &lt;br /&gt;
&lt;br /&gt;
On a ajouté 2 servos moteurs pour faire office de bras. On pourra s&#039;en servir pour proposer plus d&#039;interactions.&lt;br /&gt;
&lt;br /&gt;
== Programmation ==&lt;br /&gt;
=== fonction test ===&lt;br /&gt;
Fonction &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; qui fait clignoter les 2 LEDS :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define BLINK_DELAY 100 // en milli secondes&lt;br /&gt;
void leds()&lt;br /&gt;
{&lt;br /&gt;
    // configurer les led en sortie :&lt;br /&gt;
    DDRB |= (1 &amp;lt;&amp;lt; 4); //  LED1&lt;br /&gt;
    DDRF |= (1 &amp;lt;&amp;lt; 0); //  LED2&lt;br /&gt;
&lt;br /&gt;
    // led on&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
    PORTB ^= (1 &amp;lt;&amp;lt; 4);&lt;br /&gt;
    PORTF ^= (1 &amp;lt;&amp;lt; 0);&lt;br /&gt;
    _delay_ms(BLINK_DELAY);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File:PSE2_blink2.mp4|Blink]]&lt;br /&gt;
===Capteur ultra son===&lt;br /&gt;
On utilise un capteur ultra son &amp;lt;code&amp;gt;HC-SR04&amp;lt;/code&amp;gt;. Il a les pins 5V, GND, trigger et echo.&amp;lt;br&amp;gt;&lt;br /&gt;
Le &#039;&#039;&#039;trigger&#039;&#039;&#039; : c&#039;est le signal qu&#039;envoit le uP au capteur. Il passe à 1 -&amp;gt; le capteur envoi l&#039;onde, il retombe à 0 -&amp;gt; le capteur se &amp;quot;rendors&amp;quot;.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RC7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
void trigger(void) &lt;br /&gt;
{&lt;br /&gt;
    PORTC |= RC7;&lt;br /&gt;
    _delay_us(10);&lt;br /&gt;
    PORTC &amp;amp;= ~RC7;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;L&#039;&#039;&#039;&#039;echo&#039;&#039;&#039; : c&#039;est l&#039;onde qu’envoi le capteur. Une fois l&#039;onde envoyée, on lance un timer. Quand l&#039;onde revient sur le capteur après avoir rebondit sur l&#039;objet, le timer s&#039;arrête. &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;code&amp;gt;TCR1B&amp;lt;/code&amp;gt; configure le timer1 de l&#039;AVR soit &amp;lt;code&amp;gt;TCNT1&amp;lt;/code&amp;gt;. Mettre &amp;lt;code&amp;gt;CS11&amp;lt;/code&amp;gt; à 1 fait que le timer incrémente de 1, une fois tout les 8 coups d&#039;horloge. On a la formule &amp;lt;math&amp;gt;T_{tic} = \frac{prediviseur}{F_{CPU}}&amp;lt;/math&amp;gt;. Or ici on a un quartz de &amp;lt;code&amp;gt;8MHz&amp;lt;/code&amp;gt;, ce qui nous donne &amp;lt;math&amp;gt;T_{tic} = \frac{1}{Mz} = us&amp;lt;/math&amp;gt;. &amp;lt;br&amp;gt;&lt;br /&gt;
La vitesse du son dans l&#039;air à &amp;lt;code&amp;gt;20°C&amp;lt;/code&amp;gt; est d&#039;environ &amp;lt;code&amp;gt;340 m/s&amp;lt;/code&amp;gt;. Cela correspond à &amp;lt;code&amp;gt;0.034 cm/µs&amp;lt;/code&amp;gt;. Soit &amp;lt;math&amp;gt;d = \frac{v*t}{2}&amp;lt;/math&amp;gt; (car aller-retour) donc &amp;lt;math&amp;gt;d=\frac{0.034*t}{2} = 0.017*t = \frac{t}{59} cm = \frac{t*10}{59} mm&amp;lt;/math&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
#define RB7 (1 &amp;lt;&amp;lt; 7)&lt;br /&gt;
uint16_t echo(void)&lt;br /&gt;
{&lt;br /&gt;
    uint16_t time;&lt;br /&gt;
    trigger();&lt;br /&gt;
    while (!(PINB &amp;amp; RB7)) // On attend que l&#039;onde s&#039;envoie.&lt;br /&gt;
        ;&lt;br /&gt;
    // timer&lt;br /&gt;
    TCNT1 = 0;             // reset&lt;br /&gt;
    TCCR1B |= (1 &amp;lt;&amp;lt; CS11); // timer on (uS)&lt;br /&gt;
    while (PINB &amp;amp; (RB7))   // On attend que l&#039;onde revienne.&lt;br /&gt;
        ;&lt;br /&gt;
    time = TCNT1;&lt;br /&gt;
    return ((uint32_t)time * 10) / 59; // distance en mm&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
===Ecran===&lt;br /&gt;
&#039;&#039;&#039;Datasheets/1602A.pdf&#039;&#039;&#039;&amp;lt;br&amp;gt;&lt;br /&gt;
On utilise un écran &amp;lt;code&amp;gt;RC1602A&amp;lt;/code&amp;gt; qu&#039;on commande sur 4 bits (car manque de ports sur l&#039;arduino.) &amp;lt;br&amp;gt;&lt;br /&gt;
Pour commander l&#039;écran sur 4 bits il faut envoyer un section d&#039;octets, comme indiqué dans la data sheet : [[File: 4bit_config.png|right|700x700px]]&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void ecran_init(void)&lt;br /&gt;
{&lt;br /&gt;
    DDRC |= RS;&lt;br /&gt;
    DDRF |= (E | DB4 | DB5 | DB6 | DB7);&lt;br /&gt;
&lt;br /&gt;
    PORTC &amp;amp;= ~RS;&lt;br /&gt;
    // Init 4 bit mode&lt;br /&gt;
    _delay_ms(20);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_ms(5);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(500);&lt;br /&gt;
    send_nibble(DB4 | DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    send_nibble(DB5);&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
    // config : 0x28 = 40 = 5*8 caractères (par cases)&lt;br /&gt;
    lcd_write(0x28, 0);&lt;br /&gt;
    // Display ON/OFF Control : Allume l&#039;écran, curseur caché, pas de clignotement&lt;br /&gt;
    lcd_write(0x0C, 0);&lt;br /&gt;
    // Clear Display : Nettoie la mémoire (DDRAM)&lt;br /&gt;
    clear_display();&lt;br /&gt;
    // Entry Mode Set : Écriture de gauche à droite (incrémentation automatique)&lt;br /&gt;
    lcd_write(0x06, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
En revanche cette gestion de l&#039;écran demande 2 configuration de registres dans le &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt; avant de compiler : &amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; &#039;&#039;&#039;La gestion du Watchdog Timer (WDT) post-Bootloader&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Sur l&#039;&#039;&#039;&#039;ATmega32U4&#039;&#039;&#039;, le passage du mode de programmation (Bootloader DFU) à l&#039;application utilisateur s&#039;effectue via un redémarrage logiciel provoqué par le Watchdog Timer. Cependant, le bootloader ne désactive pas toujours ce timer avant de céder le contrôle. Comme l&#039;initialisation de l&#039;écran ici prend plusieur dizaine de millisecondes à s&#039;executer, elle dépasse le délai d&#039;expiration du Watchdog (souvent 15 ou 30 ms), le microcontrôleur subit un redémarrage d&#039;urgence en boucle. Il est donc impératif d&#039;effacer le drapeau de redémarrage dans le registre d&#039;état (&amp;lt;code&amp;gt;MCUSR = 0;&amp;lt;/code&amp;gt;) et de désactiver le timer (&amp;lt;code&amp;gt;wdt_disable();&amp;lt;/code&amp;gt;) dès la toute première ligne du &amp;lt;code&amp;gt;main()&amp;lt;/code&amp;gt; pour garantir un démarrage stable du système.&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;La libération de l&#039;interface de débogage JTAG&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Par défaut, en sortie d&#039;usine, le microcontrôleur réserve les broches &amp;lt;code&amp;gt;PF4&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;PF7&amp;lt;/code&amp;gt; au port de débogage matériel &#039;&#039;&#039;JTAG&#039;&#039;&#039;. Toute tentative logicielle de configurer ces broches en entrées/sorties standards (GPIO) via les registres &amp;lt;code&amp;gt;DDRF&amp;lt;/code&amp;gt; et &amp;lt;code&amp;gt;PORTF&amp;lt;/code&amp;gt; est matériellement ignorée. Pour récupérer le contrôle de ce port, l&#039;interface JTAG doit être désactivée. Cela s&#039;effectue en écrivant un &amp;quot;1&amp;quot; logique sur le bit &amp;lt;code&amp;gt;JTD&amp;lt;/code&amp;gt; du registre de contrôle &amp;lt;code&amp;gt;MCUCR&amp;lt;/code&amp;gt;.&amp;lt;/ul&amp;gt;Il faut le faire de manière consécutive de telle sorte à ce que cela dure moins de 4 coups d&#039;horlorge (&amp;lt;code&amp;gt;MCUCR |= (1 &amp;lt;&amp;lt; JTD); MCUCR |= (1 &amp;lt;&amp;lt; JTD);&amp;lt;/code&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Affichage de caractères standars (CGROM et DDRAM) ====&lt;br /&gt;
Une fois l&#039;écran initialisé, il est prêt à recevoir des caractères. Le contrôleur de l&#039;écran possède une mémoire morte interne appelée &#039;&#039;&#039;CGROM&#039;&#039;&#039; (Character Generator ROM) qui contient l&#039;alphabet et divers symboles pré-enregistrés.&amp;lt;br&amp;gt;&lt;br /&gt;
Pour afficher un caractère, il suffit d&#039;envoyer son code binaire correspondant à la table de la datasheet :&lt;br /&gt;
[[File: HD44780_Character_Table.png|right|1000x400px]]&lt;br /&gt;
Pour faciliter la lecture du code, tous les caractères utiles ont été mappés dans une énumération C (&amp;lt;code&amp;gt;enum Symbole&amp;lt;/code&amp;gt;).&amp;lt;br&amp;gt;&lt;br /&gt;
Cependant, il faut dire à l&#039;écran &#039;&#039;&#039;où&#039;&#039;&#039; afficher ce caractère. L&#039;écran possède une mémoire d&#039;affichage (la &#039;&#039;&#039;DDRAM&#039;&#039;&#039;). Une particularité technique importante de cet écran est que les adresses mémoires ne sont pas continues entre les deux lignes :&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 1 s&#039;étend de l&#039;adresse &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x0F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;La Ligne 2 commence à l&#039;adresse &amp;lt;code&amp;gt;0x40&amp;lt;/code&amp;gt; et va jusqu&#039;à &amp;lt;code&amp;gt;0x4F&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
[[File: DDRAM_Memory_Map.png|center|600x150px]]&lt;br /&gt;
&lt;br /&gt;
L&#039;envoi d&#039;un caractère se fait donc en deux étapes : positionner le curseur (instruction), puis envoyer le dessin (data).&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi un &#039;&#039;&#039;quartet&#039;&#039;&#039; soit 4 bits sur nos fameuses 4 entrées de l&#039;écran.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void send_nibble(uint8_t quartet)&lt;br /&gt;
{&lt;br /&gt;
    PORTF &amp;amp;= ~(RegB4 | RegB5 | RegB6 | RegB7);&lt;br /&gt;
    PORTF |= ((RegB4 | RegB5 | RegB6 | RegB7) &amp;amp; quartet);&lt;br /&gt;
    pulse_enable();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On autorise l&#039;écriture sur l&#039;écran&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void pulse_enable(void)&lt;br /&gt;
{&lt;br /&gt;
    PORTF |= RegE;&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    PORTF &amp;amp;= ~RegE;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On envoi le quartet de poids fort puis de poids faible&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void lcd_write(uint8_t data, uint8_t is_char)&lt;br /&gt;
{&lt;br /&gt;
    if (is_char) // DATA&lt;br /&gt;
    {&lt;br /&gt;
        PORTC |= RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    else // INSTRUCTION&lt;br /&gt;
    {&lt;br /&gt;
        PORTC &amp;amp;= ~RegRS;&lt;br /&gt;
    }&lt;br /&gt;
    // high&lt;br /&gt;
    send_nibble(data &amp;amp; 0xF0);&lt;br /&gt;
    _delay_us(1);&lt;br /&gt;
    // low&lt;br /&gt;
    send_nibble((data &amp;amp; 0x0F) &amp;lt;&amp;lt; 4);&lt;br /&gt;
&lt;br /&gt;
    _delay_us(50);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On se place sur la case qu&#039;on veut écrire. (0x80 : cf datasheet page 12, table des commandes)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void set_address(uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    lcd_write(0x80 + address, 0);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On écrit la data sur cette case.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_char(uint8_t data, uint8_t address)&lt;br /&gt;
{&lt;br /&gt;
    set_address(address);&lt;br /&gt;
    lcd_write(data, 1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Création d&#039;animations et limitation matérielle (CGRAM) ====&lt;br /&gt;
Pour réaliser des expressions faciales pour le robot, les symboles d&#039;usine ne suffisent pas. Le HD44780 dispose d&#039;une petite mémoire vive modifiable appelée &#039;&#039;&#039;CGRAM&#039;&#039;&#039; (Character Generator RAM).&lt;br /&gt;
Cette mémoire est très limitée : elle ne peut stocker que &#039;&#039;&#039;8 caractères personnalisés&#039;&#039;&#039; simultanément (de 5x8 pixels), indexés de &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt;.&lt;br /&gt;
Exemple de caractère fabriqué : [[File: grand_zero.png|right|500x200px]]&lt;br /&gt;
[[File: CGRAM_Address_Structure.png|right|500x200px]] &lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;L&#039;astuce de l&#039;animation :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Pour créer une animation fluide (comme un clignement d&#039;œil) sans subir le scintillement causé par l&#039;instruction clear_display(), la stratégie consiste à positionner les blocs &amp;lt;code&amp;gt;0x00&amp;lt;/code&amp;gt; à &amp;lt;code&amp;gt;0x07&amp;lt;/code&amp;gt; de manière permanente sur l&#039;écran LCD, puis à &#039;&#039;&#039;écraser les données dans la CGRAM en arrière-plan&#039;&#039;&#039;. L&#039;écran mettra automatiquement à jour l&#039;image affichée.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void charger_frame(const uint8_t matrice_complete[8][8])&lt;br /&gt;
{&lt;br /&gt;
    // On place le curseur tout au début de la mémoire CGRAM&lt;br /&gt;
    lcd_write(0x40, 0);&lt;br /&gt;
&lt;br /&gt;
    // On envoie les 64 octets (8 caractères * 8 lignes) à la suite&lt;br /&gt;
    for (uint8_t bloc = 0; bloc &amp;lt; 8; bloc++)&lt;br /&gt;
    {&lt;br /&gt;
        for (uint8_t ligne = 0; ligne &amp;lt; 8; ligne++)&lt;br /&gt;
        {&lt;br /&gt;
            lcd_write(pgm_read_byte(&amp;amp;(matrice_complete[bloc][ligne])), 1);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    // On remet le curseur sur l&#039;écran normal&lt;br /&gt;
    set_address(case1);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Gestion de la mémoire Flash (PROGMEM) :&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
Stocker de nombreuses &amp;quot;frames&amp;quot; d&#039;animation (tableaux à deux dimensions) sature immédiatement la mémoire &#039;&#039;&#039;RAM&#039;&#039;&#039; du microcontrôleur (qui ne possède que &amp;lt;code&amp;gt;2.5 Ko&amp;lt;/code&amp;gt;). Il faut forcer le compilateur à stocker ces données dans la &#039;&#039;&#039;mémoire Flash&#039;&#039;&#039; (&amp;lt;code&amp;gt;32 Ko&amp;lt;/code&amp;gt;) en utilisant la directive &#039;&#039;&#039;PROGMEM&#039;&#039;&#039; de la bibliothèque &amp;lt;code&amp;gt;&amp;lt;avr/pgmspace.h&amp;gt;&amp;lt;/code&amp;gt;.&amp;lt;br&amp;gt;&lt;br /&gt;
La lecture de ces tableaux nécessite alors une macro spécifique pgm_read_byte() (vu précédemment dans la fonction &amp;lt;code&amp;gt;charger_frame&amp;lt;/code&amp;gt;).&lt;br /&gt;
&amp;lt;br&amp;gt;Exemple d&#039;une frame :&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
const uint8_t yeux_ouverts[8][8] = {&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Gauche - Haut Gauche (0x00)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Gauche - Haut Droit  (0x01)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Gauche - Bas Gauche  (0x02)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}, // Oeil Gauche - Bas Droit   (0x03)&lt;br /&gt;
&lt;br /&gt;
    {0x00, 0x07, 0x0F, 0x1C, 0x18, 0x18, 0x18, 0x18}, // Oeil Droit - Haut Gauche  (0x04)&lt;br /&gt;
    {0x00, 0x1C, 0x1E, 0x07, 0x03, 0x03, 0x03, 0x03}, // Oeil Droit - Haut Droit   (0x05)&lt;br /&gt;
    {0x18, 0x18, 0x18, 0x1C, 0x0F, 0x07, 0x00, 0x00}, // Oeil Droit - Bas Gauche   (0x06)&lt;br /&gt;
    {0x03, 0x03, 0x03, 0x07, 0x1E, 0x1C, 0x00, 0x00}  // Oeil Droit - Bas Droit    (0x07)&lt;br /&gt;
};&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Synchronisation Écran et Capteur ====&lt;br /&gt;
Maintenant qu&#039;on a un capteur qui renvoi capte une distance en &#039;&#039;&#039;mm&#039;&#039;&#039; et un écran capable d&#039;afficher des &#039;&#039;&#039;caractères&#039;&#039;&#039; et des &#039;&#039;&#039;frames&#039;&#039;&#039; on peut les synchronisées ensemble et faire des animations.&lt;br /&gt;
Par exemple, une fonction qui affiche une barre de progression en fonction de la distance de l&#039;objet du capteur et accélère la cadence des leds en fonction de celle-ci.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void distance_barre(uint16_t distance)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t nb_carres = 0;&lt;br /&gt;
    uint16_t delay = 500;&lt;br /&gt;
&lt;br /&gt;
    if (distance &amp;gt;= 20 &amp;amp;&amp;amp; distance &amp;lt;= 340)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = (340 - distance) / 10;&lt;br /&gt;
        delay = (distance * 3) / 2;&lt;br /&gt;
    }&lt;br /&gt;
    else if (distance &amp;lt; 20)&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 32;&lt;br /&gt;
        delay = 30;&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        nb_carres = 0;&lt;br /&gt;
        delay = 500;&lt;br /&gt;
    }&lt;br /&gt;
    for (uint8_t i = 0; i &amp;lt; NBR_CASES; i++)&lt;br /&gt;
    {&lt;br /&gt;
        uint8_t address = ordre_cases[i];&lt;br /&gt;
        if (i &amp;lt; nb_carres)&lt;br /&gt;
        {&lt;br /&gt;
            afficher_char(plein, address);&lt;br /&gt;
        }&lt;br /&gt;
        else&lt;br /&gt;
        {&lt;br /&gt;
            clear_case(address);&lt;br /&gt;
        }&lt;br /&gt;
    }&lt;br /&gt;
    blink(delay);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: disctance_barre.mp4|barre]]&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
Autre exemple, une fonction qui affiche la distance de l&#039;objet en cm.&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;c&amp;quot; line=&amp;quot;1&amp;quot;&amp;gt;&lt;br /&gt;
void afficher_distance(uint16_t distance_mm)&lt;br /&gt;
{&lt;br /&gt;
    uint8_t dizaines_cm = (distance_mm / 100) % 10;&lt;br /&gt;
    uint8_t unites_cm = (distance_mm / 10) % 10;&lt;br /&gt;
    uint8_t millimetres = distance_mm % 10;&lt;br /&gt;
&lt;br /&gt;
    if (distance_mm &amp;gt;= 100)&lt;br /&gt;
    {&lt;br /&gt;
        afficher_char(dizaines_cm + &#039;0&#039;, case1); // + &#039;0&#039; convertit le chiffre en caractère ASCII&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    else&lt;br /&gt;
    {&lt;br /&gt;
        clear_case(case1);&lt;br /&gt;
        afficher_char(unites_cm + &#039;0&#039;, case2);&lt;br /&gt;
    }&lt;br /&gt;
    afficher_char(virgule, case3);&lt;br /&gt;
    afficher_char(millimetres + &#039;0&#039;, case4);&lt;br /&gt;
    afficher_char(c, case15);&lt;br /&gt;
    afficher_char(m, case16);&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
[[File: distance_cm.mp4|distance_cm]]&lt;br /&gt;
&lt;br /&gt;
== Historique des Scéances ==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;17/02 : initialisation&amp;lt;/h3&amp;gt; &lt;br /&gt;
&amp;lt;ul&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Modification initiale du wikicode &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Brainstorming pour se décider sur un projet &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;03/03 : Début de la schématique &amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Encodeur: voir si on peut en utiliser un pour régler le son/luminosité écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;li&amp;gt;Connecteur ISP (le même que le programatteur) &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;USB-A, condensateurs de découplage, condensateur VUSB. &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Chargeur Lipo (le même que celui du wiki donc à modifier selon notre schéma). &amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;haut parleur : 8 entrée DAC.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ecran : 11 entrée (8 affichage et 3 gestion).&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Cerveaux moteur optionnels si on a pas assez de ports&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Voir comment connecter la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/03 : V1 schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Push de la V1 sur le git.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;24/03 : corrections + modification chargeur LIPO&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V1, et ajout des connecteurs pour le chargement de la batterie/ choix de l&#039;alimentation / connecteur batterie&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Routage&#039;&#039;&#039; : début, du placement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt;Demander les composants physique tel que le &#039;&#039;&#039;buzzer&#039;&#039;&#039; et le &#039;&#039;&#039;cerveau moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On a enlevé des pins sur l&#039;AVR qui étaient pris inutilement par la batterie LIPO =&amp;gt; voir si on ne peut pas rajouter un cerveau moteur et des boutons à la place.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;&#039;&#039;&#039;Tension&#039;&#039;&#039; : Analyser les composants qui nécéssitent 5V de tension pour ajouter un &#039;&#039;&#039;booster de tension&#039;&#039;&#039; pour garder le 5V en batterie (3,3V). Inversement mettre un régulateur de tension sur les composants fonctionnant en 3,3V, lors de l&#039;alimentation en 5v. &#039;&#039;&#039;Convertisseur&#039;&#039;&#039; : TPS61033-Q1&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;29/03 : push de la V2 de la schématique&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du booster de tension TPS61033-Q1 pour &#039;&#039;&#039;l&#039;écran&#039;&#039;&#039;, le &#039;&#039;&#039;LM386&#039;&#039;&#039;, le &#039;&#039;&#039;capteur ultrason&#039;&#039;&#039; et les &#039;&#039;&#039;2 cervosmoteur&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout d&#039;un régulateur de tension pour la &#039;&#039;&#039;flash&#039;&#039;&#039;.&amp;lt;li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout de la section &amp;quot;Détail schématique&amp;quot; et première explication du boost et régulateur de tension.&amp;lt;li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;: &lt;br /&gt;
&amp;lt;li&amp;gt; Demander les composants physique disponibles : &#039;&#039;&#039;buzzer&#039;&#039;&#039; et les &#039;&#039;&#039;cerveaux moteur&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt; Demander une vérification de la V2 pour avancer sur le &#039;&#039;&#039;routage&#039;&#039;&#039;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;31/03 : Correction de la V2&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Correction de la V2, changement de &#039;&#039;&#039;booster&#039;&#039;&#039; et du &#039;&#039;&#039;regulateur&#039;&#039;&#039; pour simplifier le comosant et la commande sur Farnell.&amp;lt;/li&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;A FAIRE&#039;&#039;&#039;&lt;br /&gt;
&amp;lt;li&amp;gt;Modifier la section &amp;quot;détail de la schématique&amp;quot; en conséquence et revoir le dimsensionnement des composants.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;(04-05)/04 : V1 Routage&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Ajout du shifter pour la flash.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;V1 routage : Alimentation en 0.8mm, pas d&#039;angles droits, DRC au maximum, annotation avec du texte en silkscreen.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;12/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Soudures test du uP : ISP OK&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;TODO : Faut contact sur l&#039;USB. Mais carte détéctée en DFU donc pas de soucis.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;13/05 : Premières soudures&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le problème du DFU ne vient pas de l&#039;USB, mais du condensateur utilisé sur le port UCAP du uP.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Avec les 3 commandes de DFU classiques, le programme ne voulait pas se téléverser. Donc j&#039;ai utilisé &amp;lt;code&amp;gt;--force&amp;lt;/code&amp;gt; sur le &amp;lt;code&amp;gt;erase&amp;lt;/code&amp;gt;. Malheureusement cela a écrasé le code DFU sur la carte.&lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;remettre le code DFU sur l&#039;atmega&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;18/05 : Problème complation&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;DFU récupéré.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Modification de la fonction test &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Problème : Cela ne fonctionne pas.&lt;br /&gt;
&amp;lt;br&amp;gt; Soudure vérifiée patte par patte. La LED s&#039;allume avec le multimètre connecté au pin de l&#039;AVR et au GND.&lt;br /&gt;
&amp;lt;br&amp;gt;Code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; vérifié plusieurs fois pour les PINS de la LED.&lt;br /&gt;
&amp;lt;br&amp;gt;Le makefile compile le .hex et le DFU indique une validation de transfert.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;demander de l&#039;aide au prof.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;commencer à préparer le code pour l&#039;écran pour le tester à la prochaine séance.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;20/05 : Soudure nouvelle carte&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Impossible de savoir le problème -&amp;gt; soudure sur une nouvelle PCB.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le DFU fonctionne et le code &amp;lt;code&amp;gt;led.c&amp;lt;/code&amp;gt; compile bien sur la carte -&amp;gt; soudure de l&#039;écran et du capteur ultra son.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Diffcultée : le code d&#039;initalisation de l&#039;écran reboot la carte quand on essaye de le téléverser -&amp;gt; Watchdog? &amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : Fixer le code de l&#039;écran et faire des affichages avec le capteur ultra son.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;21/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Le watchdog était effectivement un des problèmes pour le fonctionnement de l&#039;avr, et aussi la désactivation du JTAG pour l&#039;utilisation des PORTF (explications aprofondis dans &amp;lt;code&amp;gt;Programmation/ecran&amp;lt;/code&amp;gt;.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;On avait aussi un problème de rétroéclairage qui etait tout simplement causé par l&#039;inversion des fils LED+ et LED -.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Des simples codes de tests donc une parfaite fonctionnalité et synchronisation entre le capteur ultra son et l&#039;écran.&amp;lt;/li&amp;gt; &lt;br /&gt;
&amp;lt;br&amp;gt;=&amp;gt; TODO : &amp;lt;br&amp;gt;- Coder des animation sur l&#039;écran.&amp;lt;br&amp;gt; - Coder des interactions avec le capteurs. &amp;lt;br&amp;gt;- Faire le lien entre les 2. &amp;lt;br&amp;gt; - Commencer le code pour chercher un fichier MP3 (ou autre fichier audio) sur le PC -&amp;gt; LUFA + LIBUSB.&amp;lt;br&amp;gt;- Demander à BOE, uP buzzer, booster, regulateur, level shifter et broche batterie.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;23/05 : Codes écran + capteur&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Avancement du code de l&#039;écran et du capteur -&amp;gt; création de la fonction &amp;lt;code&amp;gt;void afficher_distance(uint16_t distance_mm)&amp;lt;/code&amp;gt; qui affiche sur l&#039;écran la distance en live d&#039;un objet du capteur au milimètre près.&amp;lt;br&amp;gt;&lt;br /&gt;
Début des animation personnalisées -&amp;gt; création de frames.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;25/05 : animations + interactions&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&amp;lt;li&amp;gt;&lt;br /&gt;
On créé des frames sur un site de pixel art (https://www.piskelapp.com/p/create/sprite/) ensuite on les convertit grâce à un script python, en tableaux à 3 dimension (nombre de frames * nombre de cases * nombre de lignes(FRAMES*4*8 pour un oeil)). On les range donc par animation et on affiche frame par frame dans le tableau d&#039;animation associé.&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Création d&#039;un &amp;lt;code&amp;gt;enum&amp;lt;/code&amp;gt; qui différencie les états des yeux : par défaut le mode normal tourne, ce qui correspond à une animation complète qui boucle (frame 1 -&amp;gt; frame max -&amp;gt; frame 1 ...)&amp;lt;/li&amp;gt;&lt;br /&gt;
&amp;lt;li&amp;gt;Fonction avec le capteur ultra son pour détécter un mouvement brusque -&amp;gt; si mouvement brusque alors le robot pleur, sinon mode normal.&amp;lt;/li&amp;gt;&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;10/06 : Code servos&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Comme on a pas été fournit en servos moteurs on a pris nos propre servos moteurs. On a que à disposition des SG90 360° donc le code ne fonctionne pas comme on aurait voulu. Plutôt que d&#039;indiquer une valeur pour orienter le ras du servos on indique une vitesse. Et on gère les distance avec le timer1 de l&#039;AVR. Pendant le mouvement de base (quand il ne se passe rien) les servos font de petits mouvements haut /bas. QUand un mouvement est détecté,  il se mettents à faire un gros mouvement (frustration).&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;h3&amp;gt;11/06 : Tentative de réparation audio&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Après beaucoup de tentatives différents niveau software. Le buzzer faisait toujours le même son désagréable. On a fait des test aberrant en changeant une fréquence, en inversant les bits poids fort et poids faible etc. Donc aujourd&#039;hui j&#039;ai essayé de refaire les soudures, tester chaque connexion vérifier les voltages. Mais après beaucoup de tests également je n&#039;ai rien trouvé de bizarre. &lt;br /&gt;
L&#039;erreur provient peut être du routage qui aurait dut respecter une disposition très précise des résistances ? Ou peut être de l&#039;envoie des octets par le code qui n&#039;est pas bon (peut probable car le .raw est correct et on peut entendre la disctinction sonore entre 2 son. C&#039;est &amp;quot;juste&amp;quot; le son qui n&#039;est pas bon ce qui ressemble beaucoup à du hardware.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Carte électronique/Hardware ==&lt;br /&gt;
&lt;br /&gt;
Carte réalisée en utilisant le logiciel &amp;lt;code&amp;gt;KiCAD&amp;lt;/code&amp;gt; : [[File:2025-PSE-B2-systeme.zip|ma carte électronique]]. &lt;br /&gt;
&lt;br /&gt;
[[File:2025_PSE-B2-systeme-schema.pdf|thumb|left|710px|Schéma électronique]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-PCB.png|thumb|right|710px|Routage]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-front.png|thumb|left|710px|3d front]]&lt;br /&gt;
[[File:2025_PSE-B2-systeme-PCB-3D-back.png|thumb|right|710px|3d back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-front.jpg|thumb|left|710px|Soudure front]]&lt;br /&gt;
[[File:2025_PSE-02-systeme-carte-back.jpg|thumb|right|710px|Soudure back]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Vidéo très courte et en basse résolution de la carte en fonctionnement :&lt;br /&gt;
&lt;br /&gt;
[[Média:2025-PSE-02-systeme-video.mp4]]&lt;br /&gt;
&lt;br /&gt;
==== Batterie ====&lt;br /&gt;
&lt;br /&gt;
On connecte les fils de la batterie aux pins J7 (noir sur GND et rouge sur VBAT)&lt;br /&gt;
&lt;br /&gt;
sur J2&lt;br /&gt;
pour charger la batterie on viendra court-circuiter le bus ALIM avec VUSB en utilisant un jumper sur les pin de J2.&lt;br /&gt;
Et lorsqu&#039;on la branche en usb, on alimente directement l&#039;ALIM qui charge la batterie.&lt;br /&gt;
Lors de la charge de la batterie, la led d&#039;alimentation de la charge s&#039;allume quand l&#039;ALIM est alimentée.&lt;br /&gt;
En mesurant la tension de la batterie pendent qu&#039;elle charge on mesure bien 3.3V sur VBAT ce qui indique qu&#039;elle se charge sans soucis.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:batterie_charge_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Batterie en charge, tension 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Problème rencontré : &lt;br /&gt;
Comme nous n&#039;avons pas réussit à mettre le booster de tension sur notre carte du à des conflits de footprint. Notre circuit principal n&#039;est pas alilmenté par celui ci.&lt;br /&gt;
Nous devons donc procéder à des court-circuits sur J3.&lt;br /&gt;
sur J3 :&lt;br /&gt;
On à d&#039;abord court-circuité VBUS au test pointer 5V lorsque l&#039;on est alimenté par l&#039;USB.&lt;br /&gt;
Puis, on court-circuite VBAT au test pointer 5V lorsque l&#039;on utilise la batterie.&lt;br /&gt;
&lt;br /&gt;
Pour pouvoir utiliser la flash on doit faire fonctionner le regulateur de tension.&lt;br /&gt;
Comme nous n&#039;avons pas de booster, pour que le régulateur délivre 3.3V on doit court-circuiter VCC avec VUSB lorsque l&#039;USB est branché.&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:regulateur_3.3V.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Regulateur de tension, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Pour que la flash fonctionne sur batterie, on court-circuite VBAT au 3.3V&lt;br /&gt;
photo 3.3V - regulateur -batterie puis USB (2 photos)&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_batterie.jpg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement sur batterie, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:flash_sur_USB.jpeg|centré|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039;Flash en fonctionnement par USB, 3.3V&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
==== Booster de tension ====&lt;br /&gt;
Nous nous étions trompé sur la footprint de notre booster de tension. Cependant, le booster fourni utilise les même pins que notre booster voulu, donc nous avons décidé de souder chaque pin du booster de tension puis de l&#039;envelopper de colle chaude pour éviter que nos pattes faites maison ne s&#039;enlèvent (c&#039;était le cas lorsque j&#039;ai tenté de les souder sur la PCB car les pattes étaient trop fines pour être manipulées).&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_reçu.png|thumb|left|710px|Booster de tension reçu]]&lt;br /&gt;
[[Fichier:booster_footprint.png|thumb|right|710px|Footprint utilisé pour le booster de tension]]&lt;br /&gt;
&amp;lt;p style=&amp;quot;clear: both;&amp;quot; /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Comme tout les pins coincide, la flash pourrait en théorie fonctionner. Alors nous avons tenté de la souder tout de même, d&#039;une manière ou d&#039;une autre.&lt;br /&gt;
&lt;br /&gt;
[[Fichier:booster_extended.png|thumb|left|710px| Booster de tension + extensions de pattes]]&lt;br /&gt;
[[Fichier:booster_extended.png|thumb|right|710px|  Booster de tension étendu et renforcé]]&lt;br /&gt;
&lt;br /&gt;
Malheureusement je n&#039;ai jamais reussit à dépasser les 4/6 pattes soudées car la pièce était si fragile que la déplacer d&#039;un peu trop cassait la soudure. Soudure qui devait être extrêmemnt infime du à la proximités des pattes sur la footprint&lt;br /&gt;
&amp;lt;div style=&amp;quot;text-align: center;&amp;quot;&amp;gt;&lt;br /&gt;
[[Fichier:booster_extended.png|right|sans_cadre|600x600px]] &amp;lt;br /&amp;gt;&lt;br /&gt;
&#039;&#039;&#039; Dernière tentative, 4 pattes sur 6 soudées&#039;&#039;&#039; &amp;lt;br&amp;gt;&lt;br /&gt;
&amp;lt;/div&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Tout ça aurait pu être éviter si j&#039;avais lu la datasheet et la footprint correctement...&lt;br /&gt;
&lt;br /&gt;
== Détail de la schématique ==&lt;br /&gt;
&amp;lt;h3&amp;gt;Booster de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la logique (écran LCD, capteur ultra son, Haut parleur) et surtout les servomoteurs depuis la batterie de 3.3V, le choix s&#039;est porté sur le &#039;&#039;&#039;régulateur boost TPS61033-Q1&#039;&#039;&#039;. La broche FB est reliée directement à l&#039;entrée (VIN) pour fixer la tension de sortie à 5.0V en interne, rendant inutile l&#039;usage d&#039;un pont diviseur. La broche EN est maintenue à VIN pour un fonctionnement continu, tandis que la broche MODE est à la masse (GND) pour activer le mode Auto PFM. Ce mode garantit un excellent rendement énergétique à faible charge, ce qui est crucial pour économiser la batterie lorsque les moteurs sont à l&#039;arrêt. &amp;lt;br&amp;gt;&lt;br /&gt;
Pour gérer la décharge lors de l&#039;extinction, une résistance de 1kΩ (Rdummy) est placée sur la broche PG. Cela tire seulement 5mA (bien en deçà de la limite de 50mA imposée par le transistor à drain ouvert) et assure une chute de tension propre et rapide en un quart de seconde.&amp;lt;br&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Côté puissance, les servomoteurs SG90 imposent des pics de courant importants (estimés à 1.5A au total au démarrage). Pour éviter les chutes de tension critiques (brownouts), les capacités de filtrage ont été dimensionnées avec une marge de sécurité : 22µF en entrée et 47µF en sortie pour compenser la perte de capacité sous tension continue. Le cœur du convertisseur est une inductance de 0.47µH. En considérant un rendement (η), soit environ 40.6%. Le courant continu moyen demandé à la bobine se calcule via &amp;lt;math&amp;gt;I_{L(DC)} = \frac{V_{OUT} \times I_{OUT}}{V_{IN} \times \eta}&amp;lt;/math&amp;gt;, soit environ 2.53A. En y ajoutant la moitié de l&#039;ondulation crête-à-crête &amp;lt;math&amp;gt;\Delta I_{L(P-P)} = \frac{V_{IN} \times D}{L \times f_{SW}}&amp;lt;/math&amp;gt;, le courant de crête absolu atteint &amp;lt;math&amp;gt;I_{L(P)} = I_{L(DC)} + \frac{\Delta I_{L(P-P)}}{2}&amp;lt;/math&amp;gt;, soit 3.12A. L&#039;inductance choisie doit donc impérativement présenter un courant de saturation supérieur à 3.5A pour garantir la stabilité du système en pleine charge. C&#039;est pour cela qu&#039;on a choisi comme conseillé dans la datasheet l&#039;inductance &#039;&#039;&#039;XGL4020-471MEC&#039;&#039;&#039; qui peut avoir un courant de saturation allant jusqu&#039;à 6,1A.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;h3&amp;gt;Régulateur de tension&amp;lt;/h3&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
&amp;lt;ul&amp;gt;&lt;br /&gt;
Pour alimenter la mémoire flash AT45DB641E, qui requiert une tension de fonctionnement &amp;lt; 3,6V, le choix s&#039;est porté sur le &#039;&#039;&#039;convertisseur LTC3531-3.3&#039;&#039;&#039;. Contrairement à un régulateur linéaire (LDO) qui dissiperait l&#039;excédent de tension sous forme de chaleur, ce composant est un régulateur de type Buck-Boost synchrone. Cette topologie permet de maintenir une sortie de 3,3V parfaitement stable, que la tension d&#039;entrée provienne du 5V ou directement de la batterie. &amp;lt;br&amp;gt;&lt;br /&gt;
Le dimensionnement des composants périphériques s&#039;appuie sur les recommandations strictes du constructeur. L&#039;inductance de puissance a été fixée à une valeur standard de 10 µH. Cette valeur est optimisée par le fabricant pour limiter l&#039;ondulation du courant et maximiser le rendement énergétique à faible charge (la mémoire flash consommant au maximum ~25 mA lors des cycles d&#039;écriture/effacement). &amp;lt;br&amp;gt;&lt;br /&gt;
En entrée, un condensateur C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF est chargé d&#039;absorber le bruit haute fréquence et les appels de courant transitoires liés au hachage interne du régulateur. En sortie, un condensateur C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF est implanté au plus près de la broche VCC de la mémoire. Le respect de ces valeurs (L = 10 µH, C&amp;lt;sub&amp;gt;IN&amp;lt;/sub&amp;gt; = 4.7 µF, C&amp;lt;sub&amp;gt;OUT&amp;lt;/sub&amp;gt; = 10 µF) garantit que les appels de courant soudains de la puce SPI ne provoqueront aucune chute de tension hors des tolérances logiques.&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
&amp;lt;/ul&amp;gt;&lt;br /&gt;
test&lt;/div&gt;</summary>
		<author><name>Jramesh</name></author>
	</entry>
</feed>